@vikasitai/vikasit-code 2.0.6 → 2.0.8

package/src/util/filesystem.ts

@@ -1,220 +0,0 @@
-import { chmod, mkdir, readFile, stat as statFile, writeFile } from "fs/promises"
-import { createWriteStream, existsSync, statSync } from "fs"
-import { lookup } from "mime-types"
-import { realpathSync } from "fs"
-import { dirname, join, relative, resolve as pathResolve, win32 } from "path"
-import { Readable } from "stream"
-import { pipeline } from "stream/promises"
-import { Glob } from "./glob"
-
-export namespace Filesystem {
-  // Fast sync version for metadata checks
-  export async function exists(p: string): Promise<boolean> {
-    return existsSync(p)
-  }
-
-  export async function isDir(p: string): Promise<boolean> {
-    try {
-      return statSync(p).isDirectory()
-    } catch {
-      return false
-    }
-  }
-
-  export function stat(p: string): ReturnType<typeof statSync> | undefined {
-    return statSync(p, { throwIfNoEntry: false }) ?? undefined
-  }
-
-  export async function statAsync(p: string): Promise<ReturnType<typeof statSync> | undefined> {
-    return statFile(p).catch((e) => {
-      if (isEnoent(e)) return undefined
-      throw e
-    })
-  }
-
-  export async function size(p: string): Promise<number> {
-    const s = stat(p)?.size ?? 0
-    return typeof s === "bigint" ? Number(s) : s
-  }
-
-  export async function readText(p: string): Promise<string> {
-    return readFile(p, "utf-8")
-  }
-
-  export async function readJson<T = any>(p: string): Promise<T> {
-    return JSON.parse(await readFile(p, "utf-8"))
-  }
-
-  export async function readBytes(p: string): Promise<Buffer> {
-    return readFile(p)
-  }
-
-  export async function readArrayBuffer(p: string): Promise<ArrayBuffer> {
-    const buf = await readFile(p)
-    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) as ArrayBuffer
-  }
-
-  function isEnoent(e: unknown): e is { code: "ENOENT" } {
-    return typeof e === "object" && e !== null && "code" in e && (e as { code: string }).code === "ENOENT"
-  }
-
-  export async function write(p: string, content: string | Buffer | Uint8Array, mode?: number): Promise<void> {
-    try {
-      if (mode) {
-        await writeFile(p, content, { mode })
-      } else {
-        await writeFile(p, content)
-      }
-    } catch (e) {
-      if (isEnoent(e)) {
-        await mkdir(dirname(p), { recursive: true })
-        if (mode) {
-          await writeFile(p, content, { mode })
-        } else {
-          await writeFile(p, content)
-        }
-        return
-      }
-      throw e
-    }
-  }
-
-  export async function writeJson(p: string, data: unknown, mode?: number): Promise<void> {
-    return write(p, JSON.stringify(data, null, 2), mode)
-  }
-
-  export async function writeStream(
-    p: string,
-    stream: ReadableStream<Uint8Array> | Readable,
-    mode?: number,
-  ): Promise<void> {
-    const dir = dirname(p)
-    if (!existsSync(dir)) {
-      await mkdir(dir, { recursive: true })
-    }
-
-    const nodeStream = stream instanceof ReadableStream ? Readable.fromWeb(stream as any) : stream
-    const writeStream = createWriteStream(p)
-    await pipeline(nodeStream, writeStream)
-
-    if (mode) {
-      await chmod(p, mode)
-    }
-  }
-
-  export function mimeType(p: string): string {
-    return lookup(p) || "application/octet-stream"
-  }
-
-  /**
-   * On Windows, normalize a path to its canonical casing using the filesystem.
-   * This is needed because Windows paths are case-insensitive but LSP servers
-   * may return paths with different casing than what we send them.
-   */
-  export function normalizePath(p: string): string {
-    if (process.platform !== "win32") return p
-    const resolved = win32.normalize(win32.resolve(windowsPath(p)))
-    try {
-      return realpathSync.native(resolved)
-    } catch {
-      return resolved
-    }
-  }
-
-  export function normalizePathPattern(p: string): string {
-    if (process.platform !== "win32") return p
-    if (p === "*") return p
-    const match = p.match(/^(.*)[\\/]\*$/)
-    if (!match) return normalizePath(p)
-    const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1]
-    return join(normalizePath(dir), "*")
-  }
-
-  // We cannot rely on path.resolve() here because git.exe may come from Git Bash, Cygwin, or MSYS2, so we need to translate these paths at the boundary.
-  // Also resolves symlinks so that callers using the result as a cache key
-  // always get the same canonical path for a given physical directory.
-  export function resolve(p: string): string {
-    const resolved = pathResolve(windowsPath(p))
-    try {
-      return normalizePath(realpathSync(resolved))
-    } catch (e) {
-      if (isEnoent(e)) return normalizePath(resolved)
-      throw e
-    }
-  }
-
-  export function windowsPath(p: string): string {
-    if (process.platform !== "win32") return p
-    return (
-      p
-        .replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-        // Git Bash for Windows paths are typically /<drive>/...
-        .replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-        // Cygwin git paths are typically /cygdrive/<drive>/...
-        .replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-        // WSL paths are typically /mnt/<drive>/...
-        .replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`)
-    )
-  }
-  export function overlaps(a: string, b: string) {
-    const relA = relative(a, b)
-    const relB = relative(b, a)
-    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
-  }
-
-  export function contains(parent: string, child: string) {
-    return !relative(parent, child).startsWith("..")
-  }
-
-  export async function findUp(target: string, start: string, stop?: string) {
-    let current = start
-    const result = []
-    while (true) {
-      const search = join(current, target)
-      if (await exists(search)) result.push(search)
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-    return result
-  }
-
-  export async function* up(options: { targets: string[]; start: string; stop?: string }) {
-    const { targets, start, stop } = options
-    let current = start
-    while (true) {
-      for (const target of targets) {
-        const search = join(current, target)
-        if (await exists(search)) yield search
-      }
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-  }
-
-  export async function globUp(pattern: string, start: string, stop?: string) {
-    let current = start
-    const result = []
-    while (true) {
-      try {
-        const matches = await Glob.scan(pattern, {
-          cwd: current,
-          absolute: true,
-          include: "file",
-          dot: true,
-        })
-        result.push(...matches)
-      } catch {
-        // Skip invalid glob patterns
-      }
-      if (stop === current) break
-      const parent = dirname(current)
-      if (parent === current) break
-      current = parent
-    }
-    return result
-  }
-}

package/src/util/flock.ts

@@ -1,333 +0,0 @@
-import path from "path"
-import os from "os"
-import { randomBytes, randomUUID } from "crypto"
-import { mkdir, readFile, rm, stat, utimes, writeFile } from "fs/promises"
-import { Global } from "@/global"
-import { Hash } from "@/util/hash"
-
-export namespace Flock {
-  const root = path.join(Global.Path.state, "locks")
-  // Defaults for callers that do not provide timing options.
-  const defaultOpts = {
-    staleMs: 60_000,
-    timeoutMs: 5 * 60_000,
-    baseDelayMs: 100,
-    maxDelayMs: 2_000,
-  }
-
-  export interface WaitEvent {
-    key: string
-    attempt: number
-    delay: number
-    waited: number
-  }
-
-  export type Wait = (input: WaitEvent) => void | Promise<void>
-
-  export interface Options {
-    dir?: string
-    signal?: AbortSignal
-    staleMs?: number
-    timeoutMs?: number
-    baseDelayMs?: number
-    maxDelayMs?: number
-    onWait?: Wait
-  }
-
-  type Opts = {
-    staleMs: number
-    timeoutMs: number
-    baseDelayMs: number
-    maxDelayMs: number
-  }
-
-  type Owned = {
-    acquired: true
-    startHeartbeat: (intervalMs?: number) => void
-    release: () => Promise<void>
-  }
-
-  export interface Lease {
-    release: () => Promise<void>
-    [Symbol.asyncDispose]: () => Promise<void>
-  }
-
-  function code(err: unknown) {
-    if (typeof err !== "object" || err === null || !("code" in err)) return
-    const value = err.code
-    if (typeof value !== "string") return
-    return value
-  }
-
-  function sleep(ms: number, signal?: AbortSignal) {
-    return new Promise<void>((resolve, reject) => {
-      if (signal?.aborted) {
-        reject(signal.reason ?? new Error("Aborted"))
-        return
-      }
-
-      let timer: NodeJS.Timeout | undefined
-
-      const done = () => {
-        signal?.removeEventListener("abort", abort)
-        resolve()
-      }
-
-      const abort = () => {
-        if (timer) {
-          clearTimeout(timer)
-        }
-        signal?.removeEventListener("abort", abort)
-        reject(signal?.reason ?? new Error("Aborted"))
-      }
-
-      signal?.addEventListener("abort", abort, { once: true })
-      timer = setTimeout(done, ms)
-    })
-  }
-
-  function jitter(ms: number) {
-    const j = Math.floor(ms * 0.3)
-    const d = Math.floor(Math.random() * (2 * j + 1)) - j
-    return Math.max(0, ms + d)
-  }
-
-  function mono() {
-    return performance.now()
-  }
-
-  function wall() {
-    return performance.timeOrigin + mono()
-  }
-
-  async function stats(file: string) {
-    try {
-      return await stat(file)
-    } catch (err) {
-      const errCode = code(err)
-      if (errCode === "ENOENT" || errCode === "ENOTDIR") return
-      throw err
-    }
-  }
-
-  async function stale(lockDir: string, heartbeatPath: string, metaPath: string, staleMs: number) {
-    // Stale detection allows automatic recovery after crashed owners.
-    const now = wall()
-    const heartbeat = await stats(heartbeatPath)
-    if (heartbeat) {
-      return now - heartbeat.mtimeMs > staleMs
-    }
-
-    const meta = await stats(metaPath)
-    if (meta) {
-      return now - meta.mtimeMs > staleMs
-    }
-
-    const dir = await stats(lockDir)
-    if (!dir) {
-      return false
-    }
-
-    return now - dir.mtimeMs > staleMs
-  }
-
-  async function tryAcquireLockDir(lockDir: string, opts: Opts): Promise<Owned | { acquired: false }> {
-    const token = randomUUID?.() ?? randomBytes(16).toString("hex")
-    const metaPath = path.join(lockDir, "meta.json")
-    const heartbeatPath = path.join(lockDir, "heartbeat")
-
-    try {
-      await mkdir(lockDir, { mode: 0o700 })
-    } catch (err) {
-      if (code(err) !== "EEXIST") {
-        throw err
-      }
-
-      if (!(await stale(lockDir, heartbeatPath, metaPath, opts.staleMs))) {
-        return { acquired: false }
-      }
-
-      const breakerPath = lockDir + ".breaker"
-      try {
-        await mkdir(breakerPath, { mode: 0o700 })
-      } catch (claimErr) {
-        const errCode = code(claimErr)
-        if (errCode === "EEXIST") {
-          const breaker = await stats(breakerPath)
-          if (breaker && wall() - breaker.mtimeMs > opts.staleMs) {
-            await rm(breakerPath, { recursive: true, force: true }).catch(() => undefined)
-          }
-          return { acquired: false }
-        }
-
-        if (errCode === "ENOENT" || errCode === "ENOTDIR") {
-          return { acquired: false }
-        }
-
-        throw claimErr
-      }
-
-      try {
-        // Breaker ownership ensures only one contender performs stale cleanup.
-        if (!(await stale(lockDir, heartbeatPath, metaPath, opts.staleMs))) {
-          return { acquired: false }
-        }
-
-        await rm(lockDir, { recursive: true, force: true })
-
-        try {
-          await mkdir(lockDir, { mode: 0o700 })
-        } catch (retryErr) {
-          const errCode = code(retryErr)
-          if (errCode === "EEXIST" || errCode === "ENOTEMPTY") {
-            return { acquired: false }
-          }
-          throw retryErr
-        }
-      } finally {
-        await rm(breakerPath, { recursive: true, force: true }).catch(() => undefined)
-      }
-    }
-
-    const meta = {
-      token,
-      pid: process.pid,
-      hostname: os.hostname(),
-      createdAt: new Date().toISOString(),
-    }
-
-    await writeFile(heartbeatPath, "", { flag: "wx" }).catch(async () => {
-      await rm(lockDir, { recursive: true, force: true })
-      throw new Error("Lock acquired but heartbeat already existed (possible compromise).")
-    })
-
-    await writeFile(metaPath, JSON.stringify(meta, null, 2), { flag: "wx" }).catch(async () => {
-      await rm(lockDir, { recursive: true, force: true })
-      throw new Error("Lock acquired but meta.json already existed (possible compromise).")
-    })
-
-    let timer: NodeJS.Timeout | undefined
-
-    const startHeartbeat = (intervalMs = Math.max(100, Math.floor(opts.staleMs / 3))) => {
-      if (timer) return
-      // Heartbeat prevents long critical sections from being evicted as stale.
-      timer = setInterval(() => {
-        const t = new Date()
-        void utimes(heartbeatPath, t, t).catch(() => undefined)
-      }, intervalMs)
-      timer.unref?.()
-    }
-
-    const release = async () => {
-      if (timer) {
-        clearInterval(timer)
-        timer = undefined
-      }
-
-      const current = await readFile(metaPath, "utf8")
-        .then((raw) => {
-          const parsed = JSON.parse(raw)
-          if (!parsed || typeof parsed !== "object") return {}
-          return {
-            token: "token" in parsed && typeof parsed.token === "string" ? parsed.token : undefined,
-          }
-        })
-        .catch((err) => {
-          const errCode = code(err)
-          if (errCode === "ENOENT" || errCode === "ENOTDIR") {
-            throw new Error("Refusing to release: lock is compromised (metadata missing).")
-          }
-          if (err instanceof SyntaxError) {
-            throw new Error("Refusing to release: lock is compromised (metadata invalid).")
-          }
-          throw err
-        })
-      // Token check prevents deleting a lock that was re-acquired by another process.
-      if (current.token !== token) {
-        throw new Error("Refusing to release: lock token mismatch (not the owner).")
-      }
-
-      await rm(lockDir, { recursive: true, force: true })
-    }
-
-    return {
-      acquired: true,
-      startHeartbeat,
-      release,
-    }
-  }
-
-  async function acquireLockDir(
-    lockDir: string,
-    input: { key: string; onWait?: Wait; signal?: AbortSignal },
-    opts: Opts,
-  ) {
-    const stop = mono() + opts.timeoutMs
-    let attempt = 0
-    let waited = 0
-    let delay = opts.baseDelayMs
-
-    while (true) {
-      input.signal?.throwIfAborted()
-
-      const res = await tryAcquireLockDir(lockDir, opts)
-      if (res.acquired) {
-        return res
-      }
-
-      if (mono() > stop) {
-        throw new Error(`Timed out waiting for lock: ${input.key}`)
-      }
-
-      attempt += 1
-      const ms = jitter(delay)
-      await input.onWait?.({
-        key: input.key,
-        attempt,
-        delay: ms,
-        waited,
-      })
-      await sleep(ms, input.signal)
-      waited += ms
-      delay = Math.min(opts.maxDelayMs, Math.floor(delay * 1.7))
-    }
-  }
-
-  export async function acquire(key: string, input: Options = {}): Promise<Lease> {
-    input.signal?.throwIfAborted()
-    const cfg: Opts = {
-      staleMs: input.staleMs ?? defaultOpts.staleMs,
-      timeoutMs: input.timeoutMs ?? defaultOpts.timeoutMs,
-      baseDelayMs: input.baseDelayMs ?? defaultOpts.baseDelayMs,
-      maxDelayMs: input.maxDelayMs ?? defaultOpts.maxDelayMs,
-    }
-    const dir = input.dir ?? root
-
-    await mkdir(dir, { recursive: true })
-    const lockfile = path.join(dir, Hash.fast(key) + ".lock")
-    const lock = await acquireLockDir(
-      lockfile,
-      {
-        key,
-        onWait: input.onWait,
-        signal: input.signal,
-      },
-      cfg,
-    )
-    lock.startHeartbeat()
-
-    const release = () => lock.release()
-    return {
-      release,
-      [Symbol.asyncDispose]() {
-        return release()
-      },
-    }
-  }
-
-  export async function withLock<T>(key: string, fn: () => Promise<T>, input: Options = {}) {
-    await using _ = await acquire(key, input)
-    input.signal?.throwIfAborted()
-    return await fn()
-  }
-}

package/src/util/fn.ts

@@ -1,21 +0,0 @@
-import { z } from "zod"
-
-export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
-  const result = (input: z.infer<T>) => {
-    let parsed
-    try {
-      parsed = schema.parse(input)
-    } catch (e) {
-      console.trace("schema validation failure stack trace:")
-      if (e instanceof z.ZodError) {
-        console.error("schema validation issues:", JSON.stringify(e.issues, null, 2))
-      }
-      throw e
-    }
-
-    return cb(parsed)
-  }
-  result.force = (input: z.infer<T>) => cb(input)
-  result.schema = schema
-  return result
-}

package/src/util/format.ts

@@ -1,20 +0,0 @@
-export function formatDuration(secs: number) {
-  if (secs <= 0) return ""
-  if (secs < 60) return `${secs}s`
-  if (secs < 3600) {
-    const mins = Math.floor(secs / 60)
-    const remaining = secs % 60
-    return remaining > 0 ? `${mins}m ${remaining}s` : `${mins}m`
-  }
-  if (secs < 86400) {
-    const hours = Math.floor(secs / 3600)
-    const remaining = Math.floor((secs % 3600) / 60)
-    return remaining > 0 ? `${hours}h ${remaining}m` : `${hours}h`
-  }
-  if (secs < 604800) {
-    const days = Math.floor(secs / 86400)
-    return days === 1 ? "~1 day" : `~${days} days`
-  }
-  const weeks = Math.floor(secs / 604800)
-  return weeks === 1 ? "~1 week" : `~${weeks} weeks`
-}

package/src/util/git.ts

@@ -1,35 +0,0 @@
-import { Process } from "./process"
-
-export interface GitResult {
-  exitCode: number
-  text(): string
-  stdout: Buffer
-  stderr: Buffer
-}
-
-/**
- * Run a git command.
- *
- * Uses Process helpers with stdin ignored to avoid protocol pipe inheritance
- * issues in embedded/client environments.
- */
-export async function git(args: string[], opts: { cwd: string; env?: Record<string, string> }): Promise<GitResult> {
-  return Process.run(["git", ...args], {
-    cwd: opts.cwd,
-    env: opts.env,
-    stdin: "ignore",
-    nothrow: true,
-  })
-    .then((result) => ({
-      exitCode: result.code,
-      text: () => result.stdout.toString(),
-      stdout: result.stdout,
-      stderr: result.stderr,
-    }))
-    .catch((error) => ({
-      exitCode: 1,
-      text: () => "",
-      stdout: Buffer.alloc(0),
-      stderr: Buffer.from(error instanceof Error ? error.message : String(error)),
-    }))
-}

package/src/util/glob.ts

@@ -1,34 +0,0 @@
-import { glob, globSync, type GlobOptions } from "glob"
-import { minimatch } from "minimatch"
-
-export namespace Glob {
-  export interface Options {
-    cwd?: string
-    absolute?: boolean
-    include?: "file" | "all"
-    dot?: boolean
-    symlink?: boolean
-  }
-
-  function toGlobOptions(options: Options): GlobOptions {
-    return {
-      cwd: options.cwd,
-      absolute: options.absolute,
-      dot: options.dot,
-      follow: options.symlink ?? false,
-      nodir: options.include !== "all",
-    }
-  }
-
-  export async function scan(pattern: string, options: Options = {}): Promise<string[]> {
-    return glob(pattern, toGlobOptions(options)) as Promise<string[]>
-  }
-
-  export function scanSync(pattern: string, options: Options = {}): string[] {
-    return globSync(pattern, toGlobOptions(options)) as string[]
-  }
-
-  export function match(pattern: string, filepath: string): boolean {
-    return minimatch(filepath, pattern, { dot: true })
-  }
-}

package/src/util/hash.ts

@@ -1,7 +0,0 @@
-import { createHash } from "crypto"
-
-export namespace Hash {
-  export function fast(input: string | Buffer): string {
-    return createHash("sha1").update(input).digest("hex")
-  }
-}

package/src/util/iife.ts

@@ -1,3 +0,0 @@
-export function iife<T>(fn: () => T) {
-  return fn()
-}