artificial-code 1.17.13 → 1.17.14

package/src/util/repository.ts

@@ -1,232 +0,0 @@
-import path from "path"
-import { fileURLToPath } from "url"
-import { Schema } from "effect"
-import { Global } from "@ac/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.AC_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

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

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

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

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

package/src/util/wildcard.ts

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