anymous 1.0.0

package/src/util/repository.ts

@@ -0,0 +1,232 @@
+import path from "path"
+import { fileURLToPath } from "url"
+import { Schema } from "effect"
+import { Global } from "@opencode-ai/core/global"
+
+type BaseReference = {
+  host: string
+  path: string
+  segments: string[]
+  owner?: string
+  repo: string
+  remote: string
+  label: string
+}
+
+export type RemoteReference = BaseReference & {
+  protocol?: string
+}
+
+export type FileReference = BaseReference & {
+  host: "file"
+  protocol: "file:"
+}
+
+export type Reference = RemoteReference | FileReference
+
+export class InvalidRepositoryReferenceError extends Schema.TaggedErrorClass<InvalidRepositoryReferenceError>()(
+  "RepositoryInvalidReferenceError",
+  {
+    repository: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class UnsupportedLocalRepositoryError extends Schema.TaggedErrorClass<UnsupportedLocalRepositoryError>()(
+  "RepositoryUnsupportedLocalRepositoryError",
+  {
+    repository: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class InvalidRepositoryBranchError extends Schema.TaggedErrorClass<InvalidRepositoryBranchError>()(
+  "RepositoryInvalidBranchError",
+  {
+    branch: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export type RepositoryError =
+  | InvalidRepositoryReferenceError
+  | UnsupportedLocalRepositoryError
+  | InvalidRepositoryBranchError
+
+export function isRepositoryError(error: unknown): error is RepositoryError {
+  return (
+    error instanceof InvalidRepositoryReferenceError ||
+    error instanceof UnsupportedLocalRepositoryError ||
+    error instanceof InvalidRepositoryBranchError
+  )
+}
+
+function normalizeRepositoryInput(input: string) {
+  return input
+    .trim()
+    .replace(/^git\+/, "")
+    .replace(/#.*$/, "")
+    .replace(/\/+$/, "")
+}
+
+function trimGitSuffix(input: string) {
+  return input.replace(/\.git$/, "")
+}
+
+function parts(input: string) {
+  return input
+    .split("/")
+    .map((item) => trimGitSuffix(item.trim()))
+    .filter(Boolean)
+}
+
+function safeHost(input: string) {
+  return Boolean(input) && !input.startsWith("-") && !/[\s/\\]/.test(input)
+}
+
+function safeSegment(input: string) {
+  return input !== "." && input !== ".." && !input.includes(":") && !/[\s/\\]/.test(input)
+}
+
+function hostLike(input: string) {
+  return input.includes(".") || input.includes(":") || input === "localhost"
+}
+
+function withSlash(input: string) {
+  return input.endsWith("/") ? input : `${input}/`
+}
+
+function githubRemote(pathname: string) {
+  const base = process.env.OPENCODE_REPO_CLONE_GITHUB_BASE_URL
+  if (!base) return `https://github.com/${pathname}.git`
+  return new URL(`${pathname}.git`, withSlash(base)).href
+}
+
+function buildRemoteReference(input: { host: string; segments: string[]; remote?: string; protocol?: string }) {
+  const segments = input.segments.map(trimGitSuffix).filter(Boolean)
+  if (!safeHost(input.host) || !segments.length || segments.some((segment) => !safeSegment(segment))) return null
+  const pathname = segments.join("/")
+  const repo = segments[segments.length - 1]
+  const host = input.host.toLowerCase()
+  return {
+    host,
+    path: pathname,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo,
+    remote: input.remote ?? (host === "github.com" ? githubRemote(pathname) : `https://${host}/${pathname}.git`),
+    label: host === "github.com" && segments.length === 2 ? pathname : `${host}/${pathname}`,
+    protocol: input.protocol,
+  } satisfies RemoteReference
+}
+
+function buildFileReference(input: { url: URL; remote: string }) {
+  const filePath = path.normalize(fileURLToPath(input.url))
+  const segments = filePath.split(/[\\/]+/).filter(Boolean)
+  if (!segments.length) return null
+  return {
+    host: "file",
+    path: filePath,
+    segments: segments.map((segment) => segment.replace(/:$/, "")),
+    owner: undefined,
+    repo: trimGitSuffix(segments[segments.length - 1]),
+    remote: input.remote,
+    label: filePath,
+    protocol: "file:",
+  } satisfies FileReference
+}
+
+export function parseRepositoryReference(input: string) {
+  const cleaned = normalizeRepositoryInput(input)
+  if (!cleaned) return null
+
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/)
+  if (githubPrefixed) {
+    return buildRemoteReference({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] })
+  }
+
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/)
+    if (scp) return buildRemoteReference({ host: scp[1], segments: parts(scp[2]), remote: cleaned })
+
+    const direct = parts(cleaned)
+    if (direct.length >= 2 && hostLike(direct[0])) {
+      return buildRemoteReference({ host: direct[0], segments: direct.slice(1) })
+    }
+
+    if (direct.length === 2) {
+      return buildRemoteReference({ host: "github.com", segments: direct })
+    }
+  }
+
+  try {
+    const url = new URL(cleaned)
+    if (url.protocol === "file:") return buildFileReference({ url, remote: cleaned })
+    const pathname = parts(url.pathname)
+    const host = url.host
+    return buildRemoteReference({
+      host,
+      segments: pathname,
+      remote: host === "github.com" ? githubRemote(pathname.join("/")) : cleaned,
+      protocol: url.protocol,
+    })
+  } catch {
+    return null
+  }
+}
+
+export function isFileRepositoryReference(reference: Reference): reference is FileReference {
+  return reference.protocol === "file:"
+}
+
+export function isRemoteRepositoryReference(reference: Reference): reference is RemoteReference {
+  return !isFileRepositoryReference(reference)
+}
+
+export function parseRemoteRepositoryReference(input: string) {
+  const reference = parseRepositoryReference(input)
+  if (!reference) {
+    throw new InvalidRepositoryReferenceError({
+      repository: input,
+      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand",
+    })
+  }
+  if (!isRemoteRepositoryReference(reference)) {
+    throw new UnsupportedLocalRepositoryError({
+      repository: input,
+      message: "Local file repositories are not supported",
+    })
+  }
+  return reference
+}
+
+export function validateRepositoryBranch(branch: string) {
+  if (!/^[A-Za-z0-9/_.-]+$/.test(branch) || branch.startsWith("-") || branch.includes("..")) {
+    throw new InvalidRepositoryBranchError({
+      branch,
+      message:
+        "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain ..",
+    })
+  }
+}
+
+export function parseGitHubRemote(input: string) {
+  const cleaned = normalizeRepositoryInput(input)
+  if (!cleaned.includes("://") && !cleaned.match(/^(?:[^@/\s]+@)?github\.com:/)) return null
+
+  const parsed = parseRepositoryReference(cleaned)
+  if (!parsed || parsed.host !== "github.com" || !parsed.owner || parsed.segments.length !== 2) return null
+  return { owner: parsed.owner, repo: parsed.repo }
+}
+
+export function repositoryCachePath(input: Reference) {
+  return path.join(Global.Path.repos, ...input.host.split(":"), ...input.segments)
+}
+
+export function repositoryCacheIdentity(input: Reference) {
+  return `${input.host}/${input.path}`
+}
+
+export function sameRepositoryReference(left: Reference, right: Reference) {
+  return repositoryCacheIdentity(left) === repositoryCacheIdentity(right)
+}

package/src/util/rpc.ts

@@ -0,0 +1,66 @@
+type Definition = {
+  [method: string]: (input: any) => any
+}
+
+export function listen(rpc: Definition) {
+  onmessage = async (evt) => {
+    const parsed = JSON.parse(evt.data)
+    if (parsed.type === "rpc.request") {
+      const result = await rpc[parsed.method](parsed.input)
+      postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
+    }
+  }
+}
+
+export function emit(event: string, data: unknown) {
+  postMessage(JSON.stringify({ type: "rpc.event", event, data }))
+}
+
+export function client<T extends Definition>(target: {
+  postMessage: (data: string) => void | null
+  onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
+}) {
+  const pending = new Map<number, (result: any) => void>()
+  const listeners = new Map<string, Set<(data: any) => void>>()
+  let id = 0
+  target.onmessage = async (evt) => {
+    const parsed = JSON.parse(evt.data)
+    if (parsed.type === "rpc.result") {
+      const resolve = pending.get(parsed.id)
+      if (resolve) {
+        resolve(parsed.result)
+        pending.delete(parsed.id)
+      }
+    }
+    if (parsed.type === "rpc.event") {
+      const handlers = listeners.get(parsed.event)
+      if (handlers) {
+        for (const handler of handlers) {
+          handler(parsed.data)
+        }
+      }
+    }
+  }
+  return {
+    call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
+      const requestId = id++
+      return new Promise((resolve) => {
+        pending.set(requestId, resolve)
+        target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
+      })
+    },
+    on<Data>(event: string, handler: (data: Data) => void) {
+      let handlers = listeners.get(event)
+      if (!handlers) {
+        handlers = new Set()
+        listeners.set(event, handlers)
+      }
+      handlers.add(handler)
+      return () => {
+        handlers!.delete(handler)
+      }
+    },
+  }
+}
+
+export * as Rpc from "./rpc"

package/src/util/signal.ts

@@ -0,0 +1,12 @@
+export function signal() {
+  let resolve: any
+  const promise = new Promise((r) => (resolve = r))
+  return {
+    trigger() {
+      return resolve()
+    },
+    wait() {
+      return promise
+    },
+  }
+}

package/src/util/timeout.ts

@@ -0,0 +1,13 @@
+export function withTimeout<T>(promise: Promise<T>, ms: number, label?: string): Promise<T> {
+  let timeout: NodeJS.Timeout
+  return Promise.race([
+    promise.finally(() => {
+      clearTimeout(timeout)
+    }),
+    new Promise<never>((_, reject) => {
+      timeout = setTimeout(() => {
+        reject(new Error(label ?? `Operation timed out after ${ms}ms`))
+      }, ms)
+    }),
+  ])
+}

package/src/util/token.ts

@@ -0,0 +1 @@
+export { Token, estimate } from "@opencode-ai/core/util/token"

package/src/util/wildcard.ts

@@ -0,0 +1,59 @@
+import { sortBy, pipe } from "remeda"
+
+export function match(str: string, pattern: string) {
+  if (str) str = str.replaceAll("\\", "/")
+  if (pattern) pattern = pattern.replaceAll("\\", "/")
+  let escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&") // escape special regex chars
+    .replace(/\*/g, ".*") // * becomes .*
+    .replace(/\?/g, ".") // ? becomes .
+
+  // If pattern ends with " *" (space + wildcard), make the trailing part optional
+  // This allows "ls *" to match both "ls" and "ls -la"
+  if (escaped.endsWith(" .*")) {
+    escaped = escaped.slice(0, -3) + "( .*)?"
+  }
+
+  const flags = process.platform === "win32" ? "si" : "s"
+  return new RegExp("^" + escaped + "$", flags).test(str)
+}
+
+export function all(input: string, patterns: Record<string, any>) {
+  const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+  let result = undefined
+  for (const [pattern, value] of sorted) {
+    if (match(input, pattern)) {
+      result = value
+      continue
+    }
+  }
+  return result
+}
+
+export function allStructured(input: { head: string; tail: string[] }, patterns: Record<string, any>) {
+  const sorted = pipe(patterns, Object.entries, sortBy([([key]) => key.length, "asc"], [([key]) => key, "asc"]))
+  let result = undefined
+  for (const [pattern, value] of sorted) {
+    const parts = pattern.split(/\s+/)
+    if (!match(input.head, parts[0])) continue
+    if (parts.length === 1 || matchSequence(input.tail, parts.slice(1))) {
+      result = value
+      continue
+    }
+  }
+  return result
+}
+
+function matchSequence(items: string[], patterns: string[]): boolean {
+  if (patterns.length === 0) return true
+  const [pattern, ...rest] = patterns
+  if (pattern === "*") return matchSequence(items, rest)
+  for (let i = 0; i < items.length; i++) {
+    if (match(items[i], pattern) && matchSequence(items.slice(i + 1), rest)) {
+      return true
+    }
+  }
+  return false
+}
+
+export * as Wildcard from "./wildcard"