@sleepy-ai/cli 0.1.6 → 0.1.7

package/src/tool/write.ts

@@ -1,88 +0,0 @@
-import z from "zod"
-import * as path from "path"
-import { Effect } from "effect"
-import * as Tool from "./tool"
-import { LSP } from "../lsp"
-import { createTwoFilesPatch } from "diff"
-import DESCRIPTION from "./write.txt"
-import { Bus } from "../bus"
-import { File } from "../file"
-import { FileWatcher } from "../file/watcher"
-import { Format } from "../format"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { Instance } from "../project/instance"
-import { SessionCwd } from "./session-cwd"
-import { trimDiff } from "./edit"
-import { assertWriteAllowed, askEditUnlessMemory } from "./external-directory"
-
-const MAX_PROJECT_DIAGNOSTICS_FILES = 5
-
-export const WriteTool = Tool.define(
-  "write",
-  Effect.gen(function* () {
-    const lsp = yield* LSP.Service
-    const fs = yield* AppFileSystem.Service
-    const bus = yield* Bus.Service
-    const format = yield* Format.Service
-
-    return {
-      description: DESCRIPTION,
-      parameters: z.object({
-        content: z.string().describe("The content to write to the file"),
-        file_path: z.string().describe("The absolute path to the file to write (must be absolute, not relative)"),
-      }),
-      execute: (params: { content: string; file_path: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const filepath = path.isAbsolute(params.file_path)
-            ? params.file_path
-            : path.join(SessionCwd.get(ctx.sessionID), params.file_path)
-          yield* assertWriteAllowed(ctx, filepath)
-
-          const exists = yield* fs.existsSafe(filepath)
-          const contentOld = exists ? yield* fs.readFileString(filepath) : ""
-
-          const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, params.content))
-          yield* askEditUnlessMemory(ctx, filepath, {
-            patterns: [path.relative(Instance.worktree, filepath)],
-            diff,
-          })
-
-          yield* fs.writeWithDirs(filepath, params.content)
-          yield* format.file(filepath)
-          yield* bus.publish(File.Event.Edited, { file: filepath })
-          yield* bus.publish(FileWatcher.Event.Updated, {
-            file: filepath,
-            event: exists ? "change" : "add",
-          })
-
-          let output = "Wrote file successfully."
-          yield* lsp.touchFile(filepath, true)
-          const diagnostics = yield* lsp.diagnostics()
-          const normalizedFilepath = AppFileSystem.normalizePath(filepath)
-          let projectDiagnosticsCount = 0
-          for (const [file, issues] of Object.entries(diagnostics)) {
-            const current = file === normalizedFilepath
-            if (!current && projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue
-            const block = LSP.Diagnostic.report(current ? filepath : file, issues)
-            if (!block) continue
-            if (current) {
-              output += `\n\nLSP errors detected in this file, please fix:\n${block}`
-              continue
-            }
-            projectDiagnosticsCount++
-            output += `\n\nLSP errors detected in other files:\n${block}`
-          }
-
-          return {
-            title: path.relative(Instance.worktree, filepath),
-            metadata: {
-              diagnostics,
-              filepath,
-              exists: exists,
-            },
-            output,
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/write.txt

@@ -1,10 +0,0 @@
-Writes a file to the local filesystem.
-
-Usage:
-- The file_path parameter should be an absolute path.
-- This tool will overwrite the existing file if there is one at the provided path.
-- If this is an existing file, you MUST use the `read` tool first to read the file's contents. This tool will fail if you did not read the file first.
-- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
-- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
-- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.
-- For large files, prefer writing the content in multiple smaller steps rather than one big call: a single very large write may exceed the output limit and get truncated, leaving the file incomplete or corrupted. Write an initial portion with this tool, then add the remaining sections with follow-up Edit calls.

package/src/util/abort.ts

@@ -1,35 +0,0 @@
-/**
- * Creates an AbortController that automatically aborts after a timeout.
- *
- * Uses bind() instead of arrow functions to avoid capturing the surrounding
- * scope in closures. Arrow functions like `() => controller.abort()` capture
- * request bodies and other large objects, preventing GC for the timer lifetime.
- *
- * @param ms Timeout in milliseconds
- * @returns Object with controller, signal, and clearTimeout function
- */
-export function abortAfter(ms: number) {
-  const controller = new AbortController()
-  const id = setTimeout(controller.abort.bind(controller), ms)
-  return {
-    controller,
-    signal: controller.signal,
-    clearTimeout: () => globalThis.clearTimeout(id),
-  }
-}
-
-/**
- * Combines multiple AbortSignals with a timeout.
- *
- * @param ms Timeout in milliseconds
- * @param signals Additional signals to combine
- * @returns Combined signal that aborts on timeout or when any input signal aborts
- */
-export function abortAfterAny(ms: number, ...signals: AbortSignal[]) {
-  const timeout = abortAfter(ms)
-  const signal = AbortSignal.any([timeout.signal, ...signals])
-  return {
-    signal,
-    clearTimeout: timeout.clearTimeout,
-  }
-}

package/src/util/archive.ts

@@ -1,15 +0,0 @@
-import path from "path"
-import * as Process from "./process"
-
-export async function extractZip(zipPath: string, destDir: string) {
-  if (process.platform === "win32") {
-    const winZipPath = path.resolve(zipPath)
-    const winDestDir = path.resolve(destDir)
-    // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
-    const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
-    await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
-    return
-  }
-
-  await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
-}

package/src/util/color.ts

@@ -1,17 +0,0 @@
-export function isValidHex(hex?: string): hex is string {
-  if (!hex) return false
-  return /^#[0-9a-fA-F]{6}$/.test(hex)
-}
-
-export function hexToRgb(hex: string): { r: number; g: number; b: number } {
-  const r = parseInt(hex.slice(1, 3), 16)
-  const g = parseInt(hex.slice(3, 5), 16)
-  const b = parseInt(hex.slice(5, 7), 16)
-  return { r, g, b }
-}
-
-export function hexToAnsiBold(hex?: string): string | undefined {
-  if (!isValidHex(hex)) return undefined
-  const { r, g, b } = hexToRgb(hex)
-  return `\x1b[38;2;${r};${g};${b}m\x1b[1m`
-}

package/src/util/data-url.ts

@@ -1,9 +0,0 @@
-export function decodeDataUrl(url: string) {
-  const idx = url.indexOf(",")
-  if (idx === -1) return ""
-
-  const head = url.slice(0, idx)
-  const body = url.slice(idx + 1)
-  if (head.includes(";base64")) return Buffer.from(body, "base64").toString("utf8")
-  return decodeURIComponent(body)
-}

package/src/util/defer.ts

@@ -1,10 +0,0 @@
-export function defer(fn: () => void | Promise<void>): AsyncDisposable & Disposable {
-  return {
-    [Symbol.dispose]() {
-      void fn()
-    },
-    [Symbol.asyncDispose]() {
-      return Promise.resolve(fn())
-    },
-  }
-}

package/src/util/effect-http-client.ts

@@ -1,11 +0,0 @@
-import { Schedule } from "effect"
-import { HttpClient } from "effect/unstable/http"
-
-export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
-  client.pipe(
-    HttpClient.retryTransient({
-      retryOn: "errors-and-responses",
-      times: 2,
-      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
-    }),
-  )

package/src/util/effect-zod.ts

@@ -1,367 +0,0 @@
-import { Effect, Option, Schema, SchemaAST } from "effect"
-import z from "zod"
-
-/**
- * Annotation key for providing a hand-crafted Zod schema that the walker
- * should use instead of re-deriving from the AST.  Attach it via
- * `Schema.String.annotate({ [ZodOverride]: z.string().startsWith("per") })`.
- */
-export const ZodOverride: unique symbol = Symbol.for("effect-zod/override")
-
-/**
- * Annotation key for a pre-parse transform that runs on the raw input before
- * the derived Zod schema validates it.  The walker emits
- * `z.preprocess(fn, inner)` when this annotation is present.
- *
- * Models zod's `z.preprocess(fn, schema)` pattern — useful when the schema
- * needs to inspect the user's raw input (e.g. to capture insertion order)
- * before `Schema.Struct` canonicalises the object.
- *
- * TODO: This exists to paper over a missing Effect Schema feature.  The
- * parser canonicalises open struct output (known fields first in
- * declaration order, then catchall fields) before any user-defined
- * transform sees the value, and there is no pre-parse hook — so the
- * user's original property insertion order is gone by the time
- * `Schema.decodeTo` or `middlewareDecoding` runs.
- *
- * That canonicalisation is a reasonable default, but `config/permission.ts`
- * encodes rule precedence in the user's JSON key order (`evaluate.ts`
- * uses `findLast`, so later entries win), which the canonicalisation
- * silently destroys.
- *
- * The cleanest upstream fix would be either:
- *
- *   1. A `preserveInputOrder` option on `Schema.Struct` /
- *      `Schema.StructWithRest` that keeps the input's insertion order in
- *      the parsed object (opt-in; canonical order stays default).
- *   2. A generic pre-parse hook (`Schema.preprocess(schema, fn)` or a
- *      transformation whose decode receives the raw `unknown`).
- *
- * Either of those would let us delete `ZodPreprocess` and the
- * `__originalKeys` hack.  Alternatively, the permission model could move
- * to specificity-based precedence (exact keys beat wildcards) or an
- * explicit ordered array of rules, which removes the ordering
- * dependency at the data-model level.
- */
-export const ZodPreprocess: unique symbol = Symbol.for("effect-zod/preprocess")
-
-// AST nodes are immutable and frequently shared across schemas (e.g. a single
-// Schema.Class embedded in multiple parents). Memoizing by node identity
-// avoids rebuilding equivalent Zod subtrees and keeps derived children stable
-// by reference across callers.
-const walkCache = new WeakMap<SchemaAST.AST, z.ZodTypeAny>()
-
-// Shared empty ParseOptions for the rare callers that need one — avoids
-// allocating a fresh object per parse inside refinements and transforms.
-const EMPTY_PARSE_OPTIONS = {} as SchemaAST.ParseOptions
-
-export function zod<S extends Schema.Top>(schema: S): z.ZodType<Schema.Schema.Type<S>> {
-  return walk(schema.ast) as z.ZodType<Schema.Schema.Type<S>>
-}
-
-function walk(ast: SchemaAST.AST): z.ZodTypeAny {
-  const cached = walkCache.get(ast)
-  if (cached) return cached
-  const result = walkUncached(ast)
-  walkCache.set(ast, result)
-  return result
-}
-
-function walkUncached(ast: SchemaAST.AST): z.ZodTypeAny {
-  const override = (ast.annotations as any)?.[ZodOverride] as z.ZodTypeAny | undefined
-  if (override) return override
-
-  // Schema.Class wraps its fields in a Declaration AST plus an encoding that
-  // constructs the class instance. For the Zod derivation we want the plain
-  // field shape (the decoded/consumer view), not the class instance — so
-  // Declarations fall through to body(), not encoded(). User-level
-  // Schema.decodeTo / Schema.transform attach encoding to non-Declaration
-  // nodes, where we do apply the transform.
-  //
-  // Schema.withDecodingDefault also attaches encoding, but we want `.default(v)`
-  // on the inner Zod rather than a transform wrapper — so optional ASTs whose
-  // encoding resolves a default from Option.none() route through body()/opt().
-  const hasEncoding = ast.encoding?.length && ast._tag !== "Declaration"
-  const hasTransform = hasEncoding && !(SchemaAST.isOptional(ast) && extractDefault(ast) !== undefined)
-  const base = hasTransform ? encoded(ast) : body(ast)
-  const checked = ast.checks?.length ? applyChecks(base, ast.checks, ast) : base
-  const preprocess = (ast.annotations as { [ZodPreprocess]?: (val: unknown) => unknown } | undefined)?.[ZodPreprocess]
-  const out = preprocess ? z.preprocess(preprocess, checked) : checked
-  const desc = SchemaAST.resolveDescription(ast)
-  const ref = SchemaAST.resolveIdentifier(ast)
-  const described = desc ? out.describe(desc) : out
-  return ref ? described.meta({ ref }) : described
-}
-
-// Walk the encoded side and apply each link's decode to produce the decoded
-// shape. A node `Target` produced by `from.decodeTo(Target)` carries
-// `Target.encoding = [Link(from, transformation)]`. Chained decodeTo calls
-// nest the encoding via `Link.to` so walking it recursively threads all
-// prior transforms — typical encoding.length is 1.
-function encoded(ast: SchemaAST.AST): z.ZodTypeAny {
-  const encoding = ast.encoding!
-  return encoding.reduce<z.ZodTypeAny>(
-    (acc, link) => acc.transform((v) => decode(link.transformation, v)),
-    walk(encoding[0].to),
-  )
-}
-
-// Transformations built via pure `SchemaGetter.transform(fn)` (the common
-// decodeTo case) resolve synchronously, so running with no services is safe.
-// Effectful / middleware-based transforms will surface as Effect defects.
-function decode(transformation: SchemaAST.Link["transformation"], value: unknown): unknown {
-  const exit = Effect.runSyncExit(
-    (transformation.decode as any).run(Option.some(value), EMPTY_PARSE_OPTIONS) as Effect.Effect<
-      Option.Option<unknown>
-    >,
-  )
-  if (exit._tag === "Failure") throw new Error(`effect-zod: transform failed: ${String(exit.cause)}`)
-  return Option.getOrElse(exit.value, () => value)
-}
-
-// Flatten FilterGroups and any nested variants into a linear list of Filters.
-// Well-known filters (Schema.isInt, isGreaterThan, isPattern, …) are
-// translated into native Zod methods so their JSON Schema output includes
-// the corresponding constraint (type: integer, exclusiveMinimum, pattern, …).
-// Anything else falls back to a single .superRefine layer — runtime-only,
-// emits no JSON Schema constraint.
-function applyChecks(out: z.ZodTypeAny, checks: SchemaAST.Checks, ast: SchemaAST.AST): z.ZodTypeAny {
-  const filters: SchemaAST.Filter<unknown>[] = []
-  const collect = (c: SchemaAST.Check<unknown>) => {
-    if (c._tag === "FilterGroup") c.checks.forEach(collect)
-    else filters.push(c)
-  }
-  checks.forEach(collect)
-
-  const unhandled: SchemaAST.Filter<unknown>[] = []
-  const translated = filters.reduce<z.ZodTypeAny>((acc, filter) => {
-    const next = translateFilter(acc, filter)
-    if (next) return next
-    unhandled.push(filter)
-    return acc
-  }, out)
-
-  if (unhandled.length === 0) return translated
-
-  return translated.superRefine((value, ctx) => {
-    for (const filter of unhandled) {
-      const issue = filter.run(value, ast, EMPTY_PARSE_OPTIONS)
-      if (!issue) continue
-      const message = issueMessage(issue) ?? (filter.annotations as any)?.message ?? "Validation failed"
-      ctx.addIssue({ code: "custom", message })
-    }
-  })
-}
-
-// Translate a well-known Effect Schema filter into a native Zod method call on
-// `out`. Dispatch is keyed on `filter.annotations.meta._tag`, which every
-// built-in check factory (isInt, isGreaterThan, isPattern, …) attaches at
-// construction time. Returns `undefined` for unrecognised filters so the
-// caller can fall back to the generic .superRefine path.
-function translateFilter(out: z.ZodTypeAny, filter: SchemaAST.Filter<unknown>): z.ZodTypeAny | undefined {
-  const meta = (filter.annotations as { meta?: Record<string, unknown> } | undefined)?.meta
-  if (!meta || typeof meta._tag !== "string") return undefined
-  switch (meta._tag) {
-    case "isInt":
-      return call(out, "int")
-    case "isFinite":
-      return call(out, "finite")
-    case "isGreaterThan":
-      return call(out, "gt", meta.exclusiveMinimum)
-    case "isGreaterThanOrEqualTo":
-      return call(out, "gte", meta.minimum)
-    case "isLessThan":
-      return call(out, "lt", meta.exclusiveMaximum)
-    case "isLessThanOrEqualTo":
-      return call(out, "lte", meta.maximum)
-    case "isBetween": {
-      const lo = meta.exclusiveMinimum ? call(out, "gt", meta.minimum) : call(out, "gte", meta.minimum)
-      if (!lo) return undefined
-      return meta.exclusiveMaximum ? call(lo, "lt", meta.maximum) : call(lo, "lte", meta.maximum)
-    }
-    case "isMultipleOf":
-      return call(out, "multipleOf", meta.divisor)
-    case "isMinLength":
-      return call(out, "min", meta.minLength)
-    case "isMaxLength":
-      return call(out, "max", meta.maxLength)
-    case "isLengthBetween": {
-      const lo = call(out, "min", meta.minimum)
-      if (!lo) return undefined
-      return call(lo, "max", meta.maximum)
-    }
-    case "isPattern":
-      return call(out, "regex", meta.regExp)
-    case "isStartsWith":
-      return call(out, "startsWith", meta.startsWith)
-    case "isEndsWith":
-      return call(out, "endsWith", meta.endsWith)
-    case "isIncludes":
-      return call(out, "includes", meta.includes)
-    case "isUUID":
-      return call(out, "uuid")
-    case "isULID":
-      return call(out, "ulid")
-    case "isBase64":
-      return call(out, "base64")
-    case "isBase64Url":
-      return call(out, "base64url")
-  }
-  return undefined
-}
-
-// Invoke a named Zod method on `target` if it exists, otherwise return
-// undefined so the caller can fall back. Using this helper instead of a
-// typed cast keeps `translateFilter` free of per-case narrowing noise.
-function call(target: z.ZodTypeAny, method: string, ...args: unknown[]): z.ZodTypeAny | undefined {
-  const fn = (target as unknown as Record<string, ((...a: unknown[]) => z.ZodTypeAny) | undefined>)[method]
-  return typeof fn === "function" ? fn.apply(target, args) : undefined
-}
-
-function issueMessage(issue: any): string | undefined {
-  if (typeof issue?.annotations?.message === "string") return issue.annotations.message
-  if (typeof issue?.message === "string") return issue.message
-  return undefined
-}
-
-function body(ast: SchemaAST.AST): z.ZodTypeAny {
-  if (SchemaAST.isOptional(ast)) return opt(ast)
-
-  switch (ast._tag) {
-    case "String":
-      return z.string()
-    case "Number":
-      return z.number()
-    case "Boolean":
-      return z.boolean()
-    case "Null":
-      return z.null()
-    case "Undefined":
-      return z.undefined()
-    case "Any":
-    case "Unknown":
-      return z.unknown()
-    case "Never":
-      return z.never()
-    case "Literal":
-      return z.literal(ast.literal)
-    case "Union":
-      return union(ast)
-    case "Objects":
-      return object(ast)
-    case "Arrays":
-      return array(ast)
-    case "Declaration":
-      return decl(ast)
-    default:
-      return fail(ast)
-  }
-}
-
-function opt(ast: SchemaAST.AST): z.ZodTypeAny {
-  if (ast._tag !== "Union") return fail(ast)
-  const items = ast.types.filter((item) => item._tag !== "Undefined")
-  const inner =
-    items.length === 1
-      ? walk(items[0])
-      : items.length > 1
-        ? z.union(items.map(walk) as [z.ZodTypeAny, z.ZodTypeAny, ...Array<z.ZodTypeAny>])
-        : z.undefined()
-  // Schema.withDecodingDefault attaches an encoding `Link` whose transformation
-  // decode Getter resolves `Option.none()` to `Option.some(default)`.  Invoke
-  // it to extract the default and emit `.default(...)` instead of `.optional()`.
-  const fallback = extractDefault(ast)
-  if (fallback !== undefined) return inner.default(fallback.value)
-  return inner.optional()
-}
-
-type DecodeLink = {
-  readonly transformation: {
-    readonly decode: {
-      readonly run: (
-        input: Option.Option<unknown>,
-        options: SchemaAST.ParseOptions,
-      ) => Effect.Effect<Option.Option<unknown>, unknown>
-    }
-  }
-}
-
-function extractDefault(ast: SchemaAST.AST): { value: unknown } | undefined {
-  const encoding = (ast as { encoding?: ReadonlyArray<DecodeLink> }).encoding
-  if (!encoding?.length) return undefined
-  // Walk the chain of encoding Links in order; the first Getter that produces
-  // a value from Option.none wins.  withDecodingDefault always puts its
-  // defaulting Link adjacent to the optional Union.
-  for (const link of encoding) {
-    const probe = Effect.runSyncExit(link.transformation.decode.run(Option.none(), {}))
-    if (probe._tag !== "Success") continue
-    if (Option.isSome(probe.value)) return { value: probe.value.value }
-  }
-  return undefined
-}
-
-function union(ast: SchemaAST.Union): z.ZodTypeAny {
-  // When every member is a string literal, emit z.enum() so that
-  // JSON Schema produces { "enum": [...] } instead of { "anyOf": [{ "const": ... }] }.
-  if (ast.types.length >= 2 && ast.types.every((t) => t._tag === "Literal" && typeof t.literal === "string")) {
-    return z.enum(ast.types.map((t) => (t as SchemaAST.Literal).literal as string) as [string, ...string[]])
-  }
-
-  const items = ast.types.map(walk)
-  if (items.length === 1) return items[0]
-  if (items.length < 2) return fail(ast)
-
-  const discriminator = ast.annotations?.discriminator
-  if (typeof discriminator === "string") {
-    return z.discriminatedUnion(discriminator, items as [z.ZodObject<any>, z.ZodObject<any>, ...z.ZodObject<any>[]])
-  }
-
-  return z.union(items as [z.ZodTypeAny, z.ZodTypeAny, ...Array<z.ZodTypeAny>])
-}
-
-function object(ast: SchemaAST.Objects): z.ZodTypeAny {
-  // Pure record: { [k: string]: V }
-  if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 1) {
-    const sig = ast.indexSignatures[0]
-    if (sig.parameter._tag !== "String") return fail(ast)
-    return z.record(z.string(), walk(sig.type))
-  }
-
-  // Pure object with known fields and no index signatures.
-  if (ast.indexSignatures.length === 0) {
-    return z.object(Object.fromEntries(ast.propertySignatures.map((sig) => [String(sig.name), walk(sig.type)])))
-  }
-
-  // Struct with a catchall (StructWithRest): known fields + index signature.
-  // Only supports a single string-keyed index signature; multi-signature or
-  // symbol/number keys fall through to fail.
-  if (ast.indexSignatures.length !== 1) return fail(ast)
-  const sig = ast.indexSignatures[0]
-  if (sig.parameter._tag !== "String") return fail(ast)
-  return z
-    .object(Object.fromEntries(ast.propertySignatures.map((p) => [String(p.name), walk(p.type)])))
-    .catchall(walk(sig.type))
-}
-
-function array(ast: SchemaAST.Arrays): z.ZodTypeAny {
-  // Pure variadic arrays: { elements: [], rest: [item] }
-  if (ast.elements.length === 0) {
-    if (ast.rest.length !== 1) return fail(ast)
-    return z.array(walk(ast.rest[0]))
-  }
-  // Fixed-length tuples: { elements: [a, b, ...], rest: [] }
-  // Tuples with a variadic tail (...rest) are not yet supported.
-  if (ast.rest.length > 0) return fail(ast)
-  const items = ast.elements.map(walk)
-  return z.tuple(items as [z.ZodTypeAny, ...Array<z.ZodTypeAny>])
-}
-
-function decl(ast: SchemaAST.Declaration): z.ZodTypeAny {
-  if (ast.typeParameters.length !== 1) return fail(ast)
-  return walk(ast.typeParameters[0])
-}
-
-function fail(ast: SchemaAST.AST): never {
-  const ref = SchemaAST.resolveIdentifier(ast)
-  throw new Error(`unsupported effect schema: ${ref ?? ast._tag}`)
-}

package/src/util/env-info.ts

@@ -1,62 +0,0 @@
-import os from "os"
-import { Global } from "@/global"
-import { InstallationChannel, InstallationVersion } from "@/installation/version"
-import { getInstallationID } from "@/metrics/installation"
-import { SLEEPYCODE_PROCESS_ROLE, SLEEPYCODE_RUN_ID } from "./sleepy-process"
-
-function username() {
-  if (process.env.USER) return process.env.USER
-  if (process.env.USERNAME) return process.env.USERNAME
-  return os.userInfo().username
-}
-
-function locale() {
-  return Intl.DateTimeFormat().resolvedOptions().locale
-}
-
-function timezone() {
-  return Intl.DateTimeFormat().resolvedOptions().timeZone
-}
-
-export async function getEnvInfo() {
-  const cpus = os.cpus()
-
-  return {
-    os: {
-      platform: os.platform(),
-      arch: os.arch(),
-      release: os.release(),
-      hostname: os.hostname(),
-    },
-    cpu: {
-      model: cpus[0]?.model ?? "unknown",
-      count: cpus.length,
-    },
-    memory: {
-      total_bytes: os.totalmem(),
-    },
-    user: {
-      username: username(),
-      homedir: os.homedir(),
-    },
-    runtime: {
-      bun_version: Bun.version,
-      node_version: process.versions.node,
-      pid: process.pid,
-      timezone: timezone(),
-      locale: locale(),
-    },
-    paths: {
-      cwd: process.cwd(),
-      data: Global.Path.data,
-      config: Global.Path.config,
-    },
-    sleepycode: {
-      version: InstallationVersion,
-      channel: InstallationChannel,
-      installation_id: await getInstallationID(),
-      run_id: SLEEPYCODE_RUN_ID,
-      process_role: SLEEPYCODE_PROCESS_ROLE,
-    },
-  }
-}