@neurocode-ai/core 1.18.8

package/src/repository-cache.ts

@@ -0,0 +1,259 @@
+/**
+ * Local tracking checkouts for remote Git references, one per remote and
+ * branch. Each checkout permanently tracks a single ref: the requested branch
+ * when the cache key has one, otherwise the remote default branch. Content
+ * follows "newest wins": refresh fetches and hard-resets, so readers may
+ * observe the checkout move underneath them.
+ */
+import path from "path"
+import { Context, Effect, Layer, Schema } from "effect"
+import { FSUtil } from "./fs-util"
+import { Git } from "./git"
+import { Global } from "./global"
+import { Repository } from "./repository"
+import { AbsolutePath } from "./schema"
+import { makeGlobalNode } from "./effect/app-node"
+import { EffectFlock } from "./util/effect-flock"
+
+export type Result = {
+  readonly repository: string
+  readonly host: string
+  readonly remote: string
+  readonly localPath: string
+  readonly status: "cached" | "cloned" | "refreshed"
+  readonly head?: string
+  readonly branch?: string
+}
+
+export type EnsureInput = {
+  readonly reference: Repository.RemoteReference
+  readonly refresh?: boolean
+  readonly branch?: string
+}
+
+export class InvalidRepositoryError extends Schema.TaggedErrorClass<InvalidRepositoryError>()(
+  "RepositoryCacheInvalidRepositoryError",
+  {
+    repository: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class InvalidBranchError extends Schema.TaggedErrorClass<InvalidBranchError>()(
+  "RepositoryCacheInvalidBranchError",
+  {
+    branch: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class CloneFailedError extends Schema.TaggedErrorClass<CloneFailedError>()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String,
+}) {}
+
+export class FetchFailedError extends Schema.TaggedErrorClass<FetchFailedError>()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String,
+}) {}
+
+export class CheckoutFailedError extends Schema.TaggedErrorClass<CheckoutFailedError>()(
+  "RepositoryCacheCheckoutFailedError",
+  {
+    repository: Schema.String,
+    branch: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class ResetFailedError extends Schema.TaggedErrorClass<ResetFailedError>()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String,
+}) {}
+
+export class LockFailedError extends Schema.TaggedErrorClass<LockFailedError>()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String,
+}) {}
+
+export class CacheOperationError extends Schema.TaggedErrorClass<CacheOperationError>()(
+  "RepositoryCacheOperationError",
+  {
+    operation: Schema.String,
+    path: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export type Error =
+  | InvalidRepositoryError
+  | InvalidBranchError
+  | CloneFailedError
+  | FetchFailedError
+  | CheckoutFailedError
+  | ResetFailedError
+  | LockFailedError
+  | CacheOperationError
+
+export interface Interface {
+  readonly ensure: (input: EnsureInput) => Effect.Effect<Result, Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@neurocode/RepositoryCache") {}
+
+export function isError(error: unknown): error is Error {
+  return (
+    error instanceof InvalidRepositoryError ||
+    error instanceof InvalidBranchError ||
+    error instanceof CloneFailedError ||
+    error instanceof FetchFailedError ||
+    error instanceof CheckoutFailedError ||
+    error instanceof ResetFailedError ||
+    error instanceof LockFailedError ||
+    error instanceof CacheOperationError
+  )
+}
+
+export const parseRemote = Effect.fn("RepositoryCache.parseRemote")(function* (repository: string) {
+  return yield* Effect.try({
+    try: () => Repository.parseRemote(repository),
+    catch: (error) => new InvalidRepositoryError({ repository, message: errorMessage(error) }),
+  })
+})
+
+export const validateBranch = Effect.fn("RepositoryCache.validateBranch")(function* (branch: string) {
+  return yield* Effect.try({
+    try: () => Repository.validateBranch(branch),
+    catch: (error) => new InvalidBranchError({ branch, message: errorMessage(error) }),
+  })
+})
+
+const layer: Layer.Layer<Service, never, FSUtil.Service | Git.Service | EffectFlock.Service | Global.Service> =
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fs = yield* FSUtil.Service
+      const git = yield* Git.Service
+      const flock = yield* EffectFlock.Service
+      const global = yield* Global.Service
+
+      return Service.of({
+        ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+          if (input.branch) yield* validateBranch(input.branch)
+
+          const repository = input.reference.label
+          const localPath = Repository.cachePath(global.repos, input.reference, input.branch)
+          const cloneTarget = Repository.parse(input.reference.remote) ?? input.reference
+
+          return yield* flock
+            .withLock(
+              Effect.gen(function* () {
+                yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath)
+
+                const existing = yield* git.repo.discover(AbsolutePath.make(localPath))
+                const origin = existing ? yield* git.remote.get(existing) : undefined
+                const originReference = origin ? Repository.parse(origin) : undefined
+                // Discovery walks upward, so an enclosing repository with a
+                // matching origin could masquerade as the cache entry; reuse
+                // requires the checkout to live exactly at the cache path.
+                const worktree = existing ? yield* fs.resolve(localPath) : undefined
+                const reuse = Boolean(
+                  existing &&
+                    existing.worktree === worktree &&
+                    originReference &&
+                    Repository.same(originReference, cloneTarget),
+                )
+                if (!reuse && (yield* fs.existsSafe(localPath))) {
+                  yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath)
+                }
+
+                const status = !reuse
+                  ? ("cloned" as const)
+                  : input.refresh
+                    ? ("refreshed" as const)
+                    : ("cached" as const)
+
+                if (status === "cloned") {
+                  yield* git.repo
+                    .clone({
+                      remote: input.reference.remote,
+                      directory: AbsolutePath.make(localPath),
+                      branch: input.branch,
+                    })
+                    .pipe(Effect.mapError((error) => new CloneFailedError({ repository, message: error.message })))
+                }
+
+                if (status === "refreshed") {
+                  if (!existing)
+                    return yield* new FetchFailedError({ repository, message: "Repository is unavailable" })
+                  yield* git.sync
+                    .fetchRemotes(existing)
+                    .pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })))
+
+                  if (input.branch) {
+                    yield* git.sync
+                      .fetchBranch(existing, { branch: input.branch })
+                      .pipe(Effect.mapError((error) => new FetchFailedError({ repository, message: error.message })))
+                  }
+
+                  // Checking out the tracked ref before resetting keeps the
+                  // checkout self-healing even if it was left on another
+                  // branch.
+                  const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing))
+                  if (branch) {
+                    yield* git.sync
+                      .checkoutRemoteBranch(existing, { branch })
+                      .pipe(
+                        Effect.mapError(
+                          (error) => new CheckoutFailedError({ repository, branch, message: error.message }),
+                        ),
+                      )
+                  }
+
+                  const target = branch ?? (yield* git.history.branch(existing))
+                  yield* git.sync
+                    .resetHard(existing, target ? `origin/${target}` : "HEAD")
+                    .pipe(Effect.mapError((error) => new ResetFailedError({ repository, message: error.message })))
+                }
+
+                const checkout = yield* git.repo.discover(AbsolutePath.make(localPath))
+
+                return {
+                  repository,
+                  host: input.reference.host,
+                  remote: input.reference.remote,
+                  localPath,
+                  status,
+                  head: checkout ? yield* git.history.head(checkout) : undefined,
+                  branch: checkout ? yield* git.history.branch(checkout) : undefined,
+                } satisfies Result
+              }),
+              `repository-cache:${localPath}`,
+            )
+            .pipe(
+              Effect.mapError((error) =>
+                isError(error) ? error : new LockFailedError({ localPath, message: errorMessage(error) }),
+              ),
+            )
+        }),
+      })
+    }),
+  )
+
+export const node = makeGlobalNode({
+  service: Service,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, Git.node, Global.node],
+})
+
+function errorMessage(error: unknown) {
+  return error instanceof globalThis.Error ? error.message : String(error)
+}
+
+function cacheOperation<A, E, R>(effect: Effect.Effect<A, E, R>, operation: string, target: string) {
+  return effect.pipe(
+    Effect.mapError((error) => new CacheOperationError({ operation, path: target, message: errorMessage(error) })),
+  )
+}
+
+export * as RepositoryCache from "./repository-cache"

package/src/repository.ts

@@ -0,0 +1,214 @@
+import path from "path"
+import { fileURLToPath } from "url"
+import { Schema } from "effect"
+
+type BaseReference = {
+  readonly host: string
+  readonly path: string
+  readonly segments: string[]
+  readonly owner?: string
+  readonly repo: string
+  readonly remote: string
+  readonly label: string
+}
+
+export type RemoteReference = BaseReference & {
+  readonly protocol?: string
+}
+
+export type FileReference = BaseReference & {
+  readonly host: "file"
+  readonly protocol: "file:"
+}
+
+export type Reference = RemoteReference | FileReference
+
+export class InvalidReferenceError extends Schema.TaggedErrorClass<InvalidReferenceError>()(
+  "RepositoryInvalidReferenceError",
+  {
+    repository: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class UnsupportedLocalRepositoryError extends Schema.TaggedErrorClass<UnsupportedLocalRepositoryError>()(
+  "RepositoryUnsupportedLocalRepositoryError",
+  {
+    repository: Schema.String,
+    message: Schema.String,
+  },
+) {}
+
+export class InvalidBranchError extends Schema.TaggedErrorClass<InvalidBranchError>()("RepositoryInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String,
+}) {}
+
+export type Error = InvalidReferenceError | UnsupportedLocalRepositoryError | InvalidBranchError
+
+export function isError(error: unknown): error is Error {
+  return (
+    error instanceof InvalidReferenceError ||
+    error instanceof UnsupportedLocalRepositoryError ||
+    error instanceof InvalidBranchError
+  )
+}
+
+export function parse(input: string): Reference | undefined {
+  const cleaned = normalizeInput(input)
+  if (!cleaned) return
+
+  const githubPrefixed = cleaned.match(/^github:([^/\s]+)\/([^/\s]+)$/)
+  if (githubPrefixed) return buildRemote({ host: "github.com", segments: [githubPrefixed[1], githubPrefixed[2]] })
+
+  if (!cleaned.includes("://")) {
+    const scp = cleaned.match(/^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/)
+    if (scp) return buildRemote({ host: scp[1], segments: parts(scp[2]), remote: cleaned })
+
+    const direct = parts(cleaned)
+    if (direct.length >= 2 && hostLike(direct[0])) return buildRemote({ host: direct[0], segments: direct.slice(1) })
+    if (direct.length === 2) return buildRemote({ host: "github.com", segments: direct })
+  }
+
+  try {
+    const url = new URL(cleaned)
+    if (url.protocol === "file:") return buildFile({ url, remote: cleaned })
+    const segments = parts(url.pathname)
+    return buildRemote({
+      host: url.host,
+      segments,
+      remote: url.host === "github.com" ? githubRemote(segments.join("/")) : cleaned,
+      protocol: url.protocol,
+    })
+  } catch {
+    return
+  }
+}
+
+export function parseRemote(input: string): RemoteReference {
+  const reference = parse(input)
+  if (!reference) {
+    throw new InvalidReferenceError({
+      repository: input,
+      message: "Repository must be a git URL, host/path reference, or GitHub owner/repo shorthand",
+    })
+  }
+  if (!isRemote(reference)) {
+    throw new UnsupportedLocalRepositoryError({
+      repository: input,
+      message: "Local file repositories are not supported",
+    })
+  }
+  return reference
+}
+
+export function validateBranch(branch: string): void {
+  if (/^[A-Za-z0-9/_.-]+$/.test(branch) && !branch.startsWith("-") && !branch.includes("..")) return
+  throw new InvalidBranchError({
+    branch,
+    message: "Branch must contain only alphanumeric characters, /, _, ., and -, and cannot start with - or contain ..",
+  })
+}
+
+export function isFile(reference: Reference): reference is FileReference {
+  return reference.protocol === "file:"
+}
+
+export function isRemote(reference: Reference): reference is RemoteReference {
+  return !isFile(reference)
+}
+
+/**
+ * Checkouts are keyed by remote and branch: a branch-specific reference gets
+ * its own directory so branchless refreshes can never move it. The branch is
+ * percent-encoded because valid branch names may contain `/`.
+ */
+export function cachePath(root: string, reference: Reference, branch?: string): string {
+  const base = path.join(root, ...reference.host.split(":"), ...reference.segments)
+  return branch ? `${base}@${encodeURIComponent(branch)}` : base
+}
+
+export function cacheIdentity(reference: Reference): string {
+  return `${reference.host}/${reference.path}`
+}
+
+export function same(left: Reference, right: Reference): boolean {
+  return cacheIdentity(left) === cacheIdentity(right)
+}
+
+function normalizeInput(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.NEUROCODE_REPO_CLONE_GITHUB_BASE_URL
+  if (!base) return `https://github.com/${pathname}.git`
+  return new URL(`${pathname}.git`, withSlash(base)).href
+}
+
+function buildRemote(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
+  const repositoryPath = segments.join("/")
+  const host = input.host.toLowerCase()
+  return {
+    host,
+    path: repositoryPath,
+    segments,
+    owner: segments.length === 2 ? segments[0] : undefined,
+    repo: segments[segments.length - 1],
+    remote:
+      input.remote ?? (host === "github.com" ? githubRemote(repositoryPath) : `https://${host}/${repositoryPath}.git`),
+    label: host === "github.com" && segments.length === 2 ? repositoryPath : `${host}/${repositoryPath}`,
+    protocol: input.protocol,
+  } satisfies RemoteReference
+}
+
+function buildFile(input: { url: URL; remote: string }) {
+  const filePath = path.normalize(fileURLToPath(input.url))
+  const segments = filePath.split(/[\\/]+/).filter(Boolean)
+  if (!segments.length) return
+  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 * as Repository from "./repository"

package/src/ripgrep/binary.ts

@@ -0,0 +1,132 @@
+import path from "path"
+import { Context, Effect, Layer, Stream } from "effect"
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { ChildProcess } from "effect/unstable/process"
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
+import { CrossSpawnSpawner } from "../cross-spawn-spawner"
+import { makeGlobalNode } from "../effect/app-node"
+import { httpClient } from "../effect/app-node-platform"
+import { FSUtil } from "../fs-util"
+import { Global } from "../global"
+import { which } from "../util/which"
+
+export namespace RipgrepBinary {
+  const VERSION = "15.1.0"
+  const PLATFORM = {
+    "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+    "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
+    "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+    "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+    "arm64-win32": { platform: "aarch64-pc-windows-msvc", extension: "zip" },
+    "ia32-win32": { platform: "i686-pc-windows-msvc", extension: "zip" },
+    "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" },
+  } as const
+
+  interface Interface {
+    readonly filepath: Effect.Effect<string, Error>
+  }
+
+  export class Service extends Context.Service<Service, Interface>()("@neurocode/RipgrepBinary") {}
+
+  const layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const fs = yield* FSUtil.Service
+      const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient)
+      const spawner = yield* ChildProcessSpawner
+
+      const run = Effect.fnUntraced(function* (command: string, args: string[]) {
+        const handle = yield* spawner.spawn(ChildProcess.make(command, args, { extendEnv: true, stdin: "ignore" }))
+        const [stdout, stderr, code] = yield* Effect.all(
+          [
+            Stream.mkString(Stream.decodeText(handle.stdout)),
+            Stream.mkString(Stream.decodeText(handle.stderr)),
+            handle.exitCode,
+          ],
+          { concurrency: "unbounded" },
+        )
+        return { stdout, stderr, code }
+      }, Effect.scoped)
+
+      const extract = Effect.fnUntraced(function* (
+        archive: string,
+        config: (typeof PLATFORM)[keyof typeof PLATFORM],
+        target: string,
+      ) {
+        const dir = yield* fs.makeTempDirectoryScoped({ directory: Global.Path.bin, prefix: "ripgrep-" })
+
+        if (config.extension === "zip") {
+          const shell = (yield* Effect.sync(() => which("powershell.exe") ?? which("pwsh.exe"))) ?? "powershell.exe"
+          const result = yield* run(shell, [
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -LiteralPath '${archive.replaceAll("'", "''")}' -DestinationPath '${dir.replaceAll("'", "''")}' -Force`,
+          ])
+          if (result.code !== 0)
+            throw new Error(
+              result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`,
+            )
+        }
+
+        if (config.extension === "tar.gz") {
+          const result = yield* run("tar", ["-xzf", archive, "-C", dir])
+          if (result.code !== 0)
+            throw new Error(
+              result.stderr.trim() || result.stdout.trim() || `ripgrep extraction failed with code ${result.code}`,
+            )
+        }
+
+        const extracted = path.join(
+          dir,
+          `ripgrep-${VERSION}-${config.platform}`,
+          process.platform === "win32" ? "rg.exe" : "rg",
+        )
+        if (!(yield* fs.isFile(extracted))) throw new Error(`ripgrep archive did not contain executable: ${extracted}`)
+
+        yield* fs.copyFile(extracted, target)
+        if (process.platform !== "win32") yield* fs.chmod(target, 0o755)
+      }, Effect.scoped)
+
+      return Service.of({
+        filepath: yield* Effect.cached(
+          Effect.gen(function* () {
+            const system = yield* Effect.sync(() => which(process.platform === "win32" ? "rg.exe" : "rg"))
+            if (system && (yield* fs.isFile(system).pipe(Effect.orDie))) return system
+
+            const target = path.join(Global.Path.bin, `rg${process.platform === "win32" ? ".exe" : ""}`)
+            if (yield* fs.isFile(target).pipe(Effect.orDie)) return target
+
+            const platformKey = `${process.arch}-${process.platform}` as keyof typeof PLATFORM
+            const config = PLATFORM[platformKey]
+            if (!config) throw new Error(`unsupported platform for ripgrep: ${platformKey}`)
+
+            const filename = `ripgrep-${VERSION}-${config.platform}.${config.extension}`
+            const url = `https://github.com/BurntSushi/ripgrep/releases/download/${VERSION}/${filename}`
+            const archive = path.join(Global.Path.bin, filename)
+
+            yield* Effect.logInfo("downloading ripgrep", { url })
+            yield* fs.ensureDir(Global.Path.bin).pipe(Effect.orDie)
+            const bytes = yield* HttpClientRequest.get(url).pipe(
+              http.execute,
+              Effect.flatMap((response) => response.arrayBuffer),
+              Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))),
+            )
+            if (bytes.byteLength === 0) throw new Error(`failed to download ripgrep from ${url}`)
+
+            yield* fs.writeWithDirs(archive, new Uint8Array(bytes))
+            yield* extract(archive, config, target)
+            yield* fs.remove(archive, { force: true }).pipe(Effect.ignore)
+            return target
+          }),
+        ),
+      })
+    }),
+  )
+
+  export const node = makeGlobalNode({
+    service: Service,
+    layer: layer,
+    deps: [FSUtil.node, httpClient, CrossSpawnSpawner.node],
+  })
+}