anymous 1.3.0 → 1.3.2

package/src/project/vcs.ts

@@ -1,423 +0,0 @@
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { Effect, Layer, Context, Schema, Scope } from "effect"
-import { formatPatch, structuredPatch } from "diff"
-import { InstanceState } from "@/effect/instance-state"
-import { Watcher } from "@anymous-ai/core/filesystem/watcher"
-import { Git } from "@/git"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import type { EventV2 } from "@anymous-ai/core/event"
-import { VcsEvent } from "@anymous-ai/schema/vcs-event"
-
-const PATCH_CONTEXT_LINES = 2_147_483_647
-const MAX_PATCH_BYTES = 10_000_000
-const MAX_TOTAL_PATCH_BYTES = 10_000_000
-type DiffOptions = {
-  readonly context?: number
-}
-
-const emptyPatch = (file: string) => formatPatch(structuredPatch(file, file, "", "", "", "", { context: 0 }))
-
-const nums = (list: Git.Stat[]) =>
-  new Map(list.map((item) => [item.file, { additions: item.additions, deletions: item.deletions }] as const))
-
-const merge = (...lists: Git.Item[][]) => {
-  const out = new Map<string, Git.Item>()
-  lists.flat().forEach((item) => {
-    if (!out.has(item.file)) out.set(item.file, item)
-  })
-  return [...out.values()]
-}
-
-const emptyBatch = () => ({ patches: new Map<string, string>(), capped: false })
-
-const parseQuotedPath = (value: string) => {
-  let out = ""
-  for (let idx = 1; idx < value.length; idx++) {
-    const char = value[idx]
-    if (char === '"') return { value: out, end: idx + 1 }
-    if (char !== "\\") {
-      out += char
-      continue
-    }
-
-    const next = value[++idx]
-    if (next === "t") out += "\t"
-    else if (next === "n") out += "\n"
-    else if (next === "r") out += "\r"
-    else if (next === '"' || next === "\\") out += next
-    else out += next ?? ""
-  }
-}
-
-const parsePathToken = (value: string) => {
-  if (!value.startsWith('"')) return value.split("\t")[0]
-  return parseQuotedPath(value)?.value ?? value
-}
-
-const fileFromDiffPath = (value: string | undefined) => {
-  if (!value || value === "/dev/null") return
-  const file = parsePathToken(value)
-  if (file.startsWith("a/") || file.startsWith("b/")) return file.slice(2)
-  return file
-}
-
-const fileFromGitHeader = (header: string) => {
-  if (header.startsWith('"')) {
-    const first = parseQuotedPath(header)
-    const second = first ? header.slice(first.end).trimStart() : undefined
-    if (!second) return
-    if (!second.startsWith('"')) return fileFromDiffPath(second)
-    return fileFromDiffPath(parseQuotedPath(second)?.value)
-  }
-
-  const separator = header.indexOf(" b/")
-  if (separator === -1) return
-  return fileFromDiffPath(header.slice(separator + 1))
-}
-
-const fileFromPatchChunk = (chunk: string) => {
-  const next = /^\+\+\+ (.+)$/m.exec(chunk)?.[1]
-  const before = /^--- (.+)$/m.exec(chunk)?.[1]
-  const file = fileFromDiffPath(next) ?? fileFromDiffPath(before)
-  if (file) return file
-
-  const header = /^diff --git (.+)$/m.exec(chunk)?.[1]
-  return fileFromGitHeader(header ?? "")
-}
-
-const splitGitPatch = (patch: Git.Patch) => {
-  const starts = [...patch.text.matchAll(/(?:^|\n)diff --git /g)].map((match) =>
-    match[0].startsWith("\n") ? match.index + 1 : match.index,
-  )
-  const chunks = starts.map((start, index) => patch.text.slice(start, starts[index + 1] ?? patch.text.length))
-  if (!patch.truncated) return chunks
-  return chunks.slice(0, -1)
-}
-
-const batchPatches = Effect.fnUntraced(function* (
-  git: Git.Interface,
-  cwd: string,
-  ref: string,
-  list: Git.Item[],
-  options?: DiffOptions,
-) {
-  if (list.length === 0) return { patches: new Map<string, string>(), capped: false }
-
-  const result = yield* git.patchAll(cwd, ref, {
-    context: options?.context ?? PATCH_CONTEXT_LINES,
-    maxOutputBytes: MAX_TOTAL_PATCH_BYTES,
-  })
-
-  return {
-    patches: splitGitPatch(result).reduce((acc, patch, index) => {
-      const file = fileFromPatchChunk(patch) ?? list[index]?.file
-      if (!file) return acc
-      acc.set(file, (acc.get(file) ?? "") + patch)
-      return acc
-    }, new Map<string, string>()),
-    capped: result.truncated,
-  }
-})
-
-const nativePatch = Effect.fnUntraced(function* (
-  git: Git.Interface,
-  cwd: string,
-  ref: string | undefined,
-  item: Git.Item,
-  options?: DiffOptions,
-) {
-  const result =
-    item.code === "??" || !ref
-      ? yield* git.patchUntracked(cwd, item.file, {
-          context: options?.context ?? PATCH_CONTEXT_LINES,
-          maxOutputBytes: MAX_PATCH_BYTES,
-        })
-      : yield* git.patch(cwd, ref, item.file, {
-          context: options?.context ?? PATCH_CONTEXT_LINES,
-          maxOutputBytes: MAX_PATCH_BYTES,
-        })
-  if (!result.truncated && result.text) return result.text
-
-  return emptyPatch(item.file)
-})
-
-const totalPatch = (file: string, patch: string, total: number) => {
-  if (total + Buffer.byteLength(patch) <= MAX_TOTAL_PATCH_BYTES) return { patch, capped: false }
-  return { patch: emptyPatch(file), capped: true }
-}
-
-const patchForItem = Effect.fnUntraced(function* (
-  git: Git.Interface,
-  cwd: string,
-  ref: string | undefined,
-  item: Git.Item,
-  batch: { patches: Map<string, string>; capped: boolean },
-  capped: boolean,
-  options?: DiffOptions,
-) {
-  if (capped) return emptyPatch(item.file)
-
-  const batched = batch.patches.get(item.file)
-  if (batched !== undefined) return batched
-  if (item.code !== "??" && batch.capped) return emptyPatch(item.file)
-  return yield* nativePatch(git, cwd, ref, item, options)
-})
-
-const files = Effect.fnUntraced(function* (
-  git: Git.Interface,
-  cwd: string,
-  ref: string | undefined,
-  list: Git.Item[],
-  map: Map<string, { additions: number; deletions: number }>,
-  batch: { patches: Map<string, string>; capped: boolean },
-  options?: DiffOptions,
-) {
-  const next: FileDiff[] = []
-  let total = 0
-  let capped = false
-
-  for (const item of list.toSorted((a, b) => a.file.localeCompare(b.file))) {
-    const stat = map.get(item.file) ?? (item.status === "added" ? yield* git.statUntracked(cwd, item.file) : undefined)
-    const patch = yield* patchForItem(git, cwd, ref, item, batch, capped, options)
-    const result: { patch: string; capped: boolean } = capped
-      ? { patch, capped: true }
-      : totalPatch(item.file, patch, total)
-    capped = capped || result.capped
-    if (!capped) {
-      total += Buffer.byteLength(result.patch)
-      capped = total >= MAX_TOTAL_PATCH_BYTES
-    }
-    next.push({
-      file: item.file,
-      patch: result.patch,
-      additions: stat?.additions ?? 0,
-      deletions: stat?.deletions ?? 0,
-      status: item.status,
-    })
-  }
-
-  return next
-})
-
-const diffAgainstRef = Effect.fnUntraced(function* (
-  git: Git.Interface,
-  cwd: string,
-  ref: string,
-  options?: DiffOptions,
-) {
-  const [list, stats, extra] = yield* Effect.all([git.diff(cwd, ref), git.stats(cwd, ref), git.status(cwd)], {
-    concurrency: 3,
-  })
-  return yield* files(
-    git,
-    cwd,
-    ref,
-    merge(
-      list,
-      extra.filter((item) => item.code === "??"),
-    ),
-    nums(stats),
-    yield* batchPatches(git, cwd, ref, list, options),
-    options,
-  )
-})
-
-const track = Effect.fnUntraced(function* (
-  git: Git.Interface,
-  cwd: string,
-  ref: string | undefined,
-  options?: DiffOptions,
-) {
-  if (!ref) return yield* files(git, cwd, ref, yield* git.status(cwd), new Map(), emptyBatch(), options)
-  return yield* diffAgainstRef(git, cwd, ref, options)
-})
-
-export const Mode = Schema.Literals(["git", "branch"])
-export type Mode = Schema.Schema.Type<typeof Mode>
-
-export const Event = VcsEvent
-
-export const Info = Schema.Struct({
-  branch: Schema.optional(Schema.String),
-  default_branch: Schema.optional(Schema.String),
-}).annotate({ identifier: "VcsInfo" })
-export type Info = Schema.Schema.Type<typeof Info>
-
-export const FileDiff = Schema.Struct({
-  file: Schema.String,
-  // Mirrors Snapshot.FileDiff (see #26574). The current producer always
-  // populates patch, but loosening matches the sibling schema so a
-  // future code path that omits it can't crash /instance/vcs/diff.
-  patch: Schema.optional(Schema.String),
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  status: Schema.optional(Schema.Literals(["added", "deleted", "modified"])),
-}).annotate({ identifier: "VcsFileDiff" })
-export type FileDiff = Schema.Schema.Type<typeof FileDiff>
-
-export const FileStatus = Schema.Struct({
-  file: Schema.String,
-  additions: Schema.Finite,
-  deletions: Schema.Finite,
-  status: Schema.Literals(["added", "deleted", "modified"]),
-}).annotate({ identifier: "VcsFileStatus" })
-export type FileStatus = Schema.Schema.Type<typeof FileStatus>
-
-export const ApplyInput = Schema.Struct({
-  patch: Schema.String,
-})
-export type ApplyInput = Schema.Schema.Type<typeof ApplyInput>
-
-export const ApplyResult = Schema.Struct({
-  applied: Schema.Boolean,
-})
-export type ApplyResult = Schema.Schema.Type<typeof ApplyResult>
-
-export class PatchApplyError extends Schema.TaggedErrorClass<PatchApplyError>()("VcsPatchApplyError", {
-  message: Schema.String,
-  reason: Schema.Literals(["non-git", "not-clean"]),
-}) {}
-
-export interface Interface {
-  readonly init: () => Effect.Effect<void>
-  readonly branch: () => Effect.Effect<string | undefined>
-  readonly defaultBranch: () => Effect.Effect<string | undefined>
-  readonly status: () => Effect.Effect<FileStatus[]>
-  readonly diff: (mode: Mode, options?: DiffOptions) => Effect.Effect<FileDiff[]>
-  readonly diffRaw: () => Effect.Effect<string>
-  readonly apply: (input: ApplyInput) => Effect.Effect<ApplyResult, PatchApplyError>
-}
-
-interface State {
-  current: string | undefined
-  root: Git.Base | undefined
-}
-
-export class Service extends Context.Service<Service, Interface>()("@anymous/Vcs") {}
-
-const layer: Layer.Layer<Service, never, Git.Service | EventV2Bridge.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const git = yield* Git.Service
-    const events = yield* EventV2Bridge.Service
-    const scope = yield* Scope.Scope
-
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("Vcs.state")(function* (ctx) {
-        if (ctx.project.vcs !== "git") {
-          return { current: undefined, root: undefined }
-        }
-
-        const get = Effect.fnUntraced(function* () {
-          return yield* git.branch(ctx.directory)
-        })
-        const [current, root] = yield* Effect.all([git.branch(ctx.directory), git.defaultBranch(ctx.directory)], {
-          concurrency: 2,
-        })
-        const value = { current, root }
-
-        const unsubscribe = yield* events.listen((event) => {
-          if (event.type !== Watcher.Event.Updated.type || event.location?.directory !== ctx.directory)
-            return Effect.void
-          const data = event.data as EventV2.Data<typeof Watcher.Event.Updated>
-          if (!data.file.endsWith("HEAD")) return Effect.void
-          return Effect.gen(function* () {
-            const next = yield* get()
-            if (next !== value.current) {
-              value.current = next
-              yield* events.publish(Event.BranchUpdated, { branch: next })
-            }
-          })
-        })
-        yield* Effect.addFinalizer(() => unsubscribe)
-
-        return value
-      }),
-    )
-
-    return Service.of({
-      init: Effect.fn("Vcs.init")(function* () {
-        yield* InstanceState.get(state).pipe(Effect.forkIn(scope))
-      }),
-      branch: Effect.fn("Vcs.branch")(function* () {
-        return yield* InstanceState.use(state, (x) => x.current)
-      }),
-      defaultBranch: Effect.fn("Vcs.defaultBranch")(function* () {
-        return yield* InstanceState.use(state, (x) => x.root?.name)
-      }),
-      status: Effect.fn("Vcs.status")(function* () {
-        const ctx = yield* InstanceState.context
-        if (ctx.project.vcs !== "git") return []
-        const ref = (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined
-        const [list, stats] = yield* Effect.all(
-          [git.status(ctx.directory), ref ? git.stats(ctx.directory, ref) : Effect.succeed([])],
-          { concurrency: 2 },
-        )
-        const map = nums(stats)
-        return yield* Effect.forEach(
-          list.toSorted((a, b) => a.file.localeCompare(b.file)),
-          (item) =>
-            Effect.gen(function* () {
-              const stat =
-                map.get(item.file) ??
-                (item.status === "added" ? yield* git.statUntracked(ctx.worktree, item.file) : undefined)
-              return {
-                file: item.file,
-                additions: stat?.additions ?? 0,
-                deletions: stat?.deletions ?? 0,
-                status: item.status,
-              } satisfies FileStatus
-            }),
-        )
-      }),
-      diff: Effect.fn("Vcs.diff")(function* (mode: Mode, options?: DiffOptions) {
-        const value = yield* InstanceState.get(state)
-        const ctx = yield* InstanceState.context
-        if (ctx.project.vcs !== "git") return []
-        if (mode === "git") {
-          return yield* track(git, ctx.directory, (yield* git.hasHead(ctx.directory)) ? "HEAD" : undefined, options)
-        }
-
-        if (!value.root) return []
-        if (value.current && value.current === value.root.name) return []
-        const ref = yield* git.mergeBase(ctx.directory, value.root.ref)
-        if (!ref) return []
-        return yield* diffAgainstRef(git, ctx.directory, ref, options)
-      }),
-      diffRaw: Effect.fn("Vcs.diffRaw")(function* () {
-        const ctx = yield* InstanceState.context
-        if (ctx.project.vcs !== "git") return ""
-        const [hasHead, status] = yield* Effect.all([git.hasHead(ctx.directory), git.status(ctx.directory)], {
-          concurrency: 2,
-        })
-        const tracked = hasHead ? (yield* git.patchAll(ctx.directory, "HEAD")).text : ""
-        const untracked = yield* Effect.forEach(
-          status.filter((item) => item.code === "??"),
-          (item) => git.patchUntracked(ctx.directory, item.file).pipe(Effect.map((patch) => patch.text)),
-        )
-        return [tracked, ...untracked].filter(Boolean).join("\n")
-      }),
-      apply: Effect.fn("Vcs.apply")(function* (input: ApplyInput) {
-        const ctx = yield* InstanceState.context
-        if (ctx.project.vcs !== "git") {
-          return yield* new PatchApplyError({
-            message: "Patch can't be applied because the project is not git-based",
-            reason: "non-git",
-          })
-        }
-        const applied = yield* git.applyPatch(ctx.directory, input.patch)
-        if (applied.exitCode !== 0) {
-          return yield* new PatchApplyError({
-            message: "Patch can't be applied",
-            reason: "not-clean",
-          })
-        }
-        return { applied: true }
-      }),
-    })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Git.node, EventV2Bridge.node] })
-
-export * as Vcs from "./vcs"

package/src/provider/auth.ts

@@ -1,229 +0,0 @@
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import type { AuthOAuthResult, Hooks } from "@anymous-ai/plugin"
-import { serviceUse } from "@anymous-ai/core/effect/service-use"
-import { Auth } from "@/auth"
-import { InstanceState } from "@/effect/instance-state"
-import { optional } from "@anymous-ai/core/schema"
-import { Plugin } from "../plugin"
-import { ProviderV2 } from "@anymous-ai/core/provider"
-import { Array as Arr, Effect, Layer, Record, Result, Context, Schema } from "effect"
-
-const When = Schema.Struct({
-  key: Schema.String,
-  op: Schema.Literals(["eq", "neq"]),
-  value: Schema.String,
-})
-
-const TextPrompt = Schema.Struct({
-  type: Schema.Literal("text"),
-  key: Schema.String,
-  message: Schema.String,
-  placeholder: optional(Schema.String),
-  when: optional(When),
-})
-
-const SelectOption = Schema.Struct({
-  label: Schema.String,
-  value: Schema.String,
-  hint: optional(Schema.String),
-})
-
-const SelectPrompt = Schema.Struct({
-  type: Schema.Literal("select"),
-  key: Schema.String,
-  message: Schema.String,
-  options: Schema.Array(SelectOption),
-  when: optional(When),
-})
-
-const Prompt = Schema.Union([TextPrompt, SelectPrompt])
-
-export class Method extends Schema.Class<Method>("ProviderAuthMethod")({
-  type: Schema.Literals(["oauth", "api"]),
-  label: Schema.String,
-  prompts: optional(Schema.Array(Prompt)),
-}) {}
-
-export const Methods = Schema.Record(Schema.String, Schema.Array(Method))
-export type Methods = typeof Methods.Type
-
-export class Authorization extends Schema.Class<Authorization>("ProviderAuthAuthorization")({
-  url: Schema.String,
-  method: Schema.Literals(["auto", "code"]),
-  instructions: Schema.String,
-}) {}
-
-export const AuthorizeInput = Schema.Struct({
-  method: Schema.Finite.annotate({ description: "Auth method index" }),
-  inputs: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({ description: "Prompt inputs" }),
-})
-export type AuthorizeInput = Schema.Schema.Type<typeof AuthorizeInput>
-
-export const CallbackInput = Schema.Struct({
-  method: Schema.Finite.annotate({ description: "Auth method index" }),
-  code: Schema.optional(Schema.String).annotate({ description: "OAuth authorization code" }),
-})
-export type CallbackInput = Schema.Schema.Type<typeof CallbackInput>
-
-export class OauthMissing extends Schema.TaggedErrorClass<OauthMissing>()("ProviderAuthOauthMissing", {
-  providerID: ProviderV2.ID,
-}) {}
-
-export class OauthCodeMissing extends Schema.TaggedErrorClass<OauthCodeMissing>()("ProviderAuthOauthCodeMissing", {
-  providerID: ProviderV2.ID,
-}) {}
-
-export class OauthCallbackFailed extends Schema.TaggedErrorClass<OauthCallbackFailed>()(
-  "ProviderAuthOauthCallbackFailed",
-  {},
-) {}
-
-export class ValidationFailed extends Schema.TaggedErrorClass<ValidationFailed>()("ProviderAuthValidationFailed", {
-  field: Schema.String,
-  message: Schema.String,
-}) {}
-
-export type Error = Auth.AuthError | OauthMissing | OauthCodeMissing | OauthCallbackFailed | ValidationFailed
-
-type Hook = NonNullable<Hooks["auth"]>
-
-export interface Interface {
-  readonly methods: () => Effect.Effect<Methods>
-  readonly authorize: (
-    input: {
-      providerID: ProviderV2.ID
-    } & AuthorizeInput,
-  ) => Effect.Effect<Authorization | undefined, Error>
-  readonly callback: (input: { providerID: ProviderV2.ID } & CallbackInput) => Effect.Effect<void, Error>
-}
-
-interface State {
-  hooks: Record<ProviderV2.ID, Hook>
-  pending: Map<ProviderV2.ID, AuthOAuthResult>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@anymous/ProviderAuth") {}
-
-export const use = serviceUse(Service)
-
-const layer: Layer.Layer<Service, never, Auth.Service | Plugin.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const auth = yield* Auth.Service
-    const plugin = yield* Plugin.Service
-    const state = yield* InstanceState.make<State>(
-      Effect.fn("ProviderAuth.state")(function* () {
-        const plugins = yield* plugin.list()
-        return {
-          hooks: Record.fromEntries(
-            Arr.filterMap(plugins, (x) =>
-              x.auth?.provider !== undefined
-                ? Result.succeed([ProviderV2.ID.make(x.auth.provider), x.auth] as const)
-                : Result.failVoid,
-            ),
-          ),
-          pending: new Map<ProviderV2.ID, AuthOAuthResult>(),
-        }
-      }),
-    )
-
-    const decode = Schema.decodeUnknownSync(Methods)
-    const methods = Effect.fn("ProviderAuth.methods")(function* () {
-      const hooks = (yield* InstanceState.get(state)).hooks
-      return decode(
-        Record.map(hooks, (item) =>
-          item.methods.map((method) => ({
-            type: method.type,
-            label: method.label,
-            ...(method.prompts && {
-              prompts: method.prompts.map((prompt) => {
-                if (prompt.type === "select") {
-                  return {
-                    type: "select" as const,
-                    key: prompt.key,
-                    message: prompt.message,
-                    options: prompt.options,
-                    ...(prompt.when && { when: prompt.when }),
-                  }
-                }
-                return {
-                  type: "text" as const,
-                  key: prompt.key,
-                  message: prompt.message,
-                  ...(prompt.placeholder && { placeholder: prompt.placeholder }),
-                  ...(prompt.when && { when: prompt.when }),
-                }
-              }),
-            }),
-          })),
-        ),
-      )
-    })
-
-    const authorize = Effect.fn("ProviderAuth.authorize")(function* (
-      input: { providerID: ProviderV2.ID } & AuthorizeInput,
-    ) {
-      const { hooks, pending } = yield* InstanceState.get(state)
-      const method = hooks[input.providerID].methods[input.method]
-      if (method.type !== "oauth") return
-
-      if (method.prompts && input.inputs) {
-        for (const prompt of method.prompts) {
-          if (prompt.type === "text" && prompt.validate && input.inputs[prompt.key] !== undefined) {
-            const error = prompt.validate(input.inputs[prompt.key])
-            if (error) return yield* new ValidationFailed({ field: prompt.key, message: error })
-          }
-        }
-      }
-
-      const result = yield* Effect.promise(() => method.authorize(input.inputs))
-      pending.set(input.providerID, result)
-      return {
-        url: result.url,
-        method: result.method,
-        instructions: result.instructions,
-      }
-    })
-
-    const callback = Effect.fn("ProviderAuth.callback")(function* (
-      input: { providerID: ProviderV2.ID } & CallbackInput,
-    ) {
-      const pending = (yield* InstanceState.get(state)).pending
-      const match = pending.get(input.providerID)
-      if (!match) return yield* new OauthMissing({ providerID: input.providerID })
-      if (match.method === "code" && !input.code) {
-        return yield* new OauthCodeMissing({ providerID: input.providerID })
-      }
-
-      const result = yield* Effect.promise(() =>
-        match.method === "code" ? match.callback(input.code!) : match.callback(),
-      )
-      if (!result || result.type !== "success") return yield* new OauthCallbackFailed({})
-
-      if ("key" in result) {
-        yield* auth.set(input.providerID, {
-          type: "api",
-          key: result.key,
-          ...(result.metadata ? { metadata: result.metadata } : {}),
-        })
-      }
-
-      if ("refresh" in result) {
-        const { type: _, provider: __, refresh, access, expires, ...extra } = result
-        yield* auth.set(input.providerID, {
-          type: "oauth",
-          access,
-          refresh,
-          expires,
-          ...extra,
-        })
-      }
-    })
-
-    return Service.of({ methods, authorize, callback })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [Auth.node, Plugin.node] })
-
-export * as ProviderAuth from "./auth"