codepro-ia 1.0.0

package/src/util/lock.ts

@@ -0,0 +1,98 @@
+export namespace Lock {
+  const locks = new Map<
+    string,
+    {
+      readers: number
+      writer: boolean
+      waitingReaders: (() => void)[]
+      waitingWriters: (() => void)[]
+    }
+  >()
+
+  function get(key: string) {
+    if (!locks.has(key)) {
+      locks.set(key, {
+        readers: 0,
+        writer: false,
+        waitingReaders: [],
+        waitingWriters: [],
+      })
+    }
+    return locks.get(key)!
+  }
+
+  function process(key: string) {
+    const lock = locks.get(key)
+    if (!lock || lock.writer || lock.readers > 0) return
+
+    // Prioritize writers to prevent starvation
+    if (lock.waitingWriters.length > 0) {
+      const nextWriter = lock.waitingWriters.shift()!
+      nextWriter()
+      return
+    }
+
+    // Wake up all waiting readers
+    while (lock.waitingReaders.length > 0) {
+      const nextReader = lock.waitingReaders.shift()!
+      nextReader()
+    }
+
+    // Clean up empty locks
+    if (lock.readers === 0 && !lock.writer && lock.waitingReaders.length === 0 && lock.waitingWriters.length === 0) {
+      locks.delete(key)
+    }
+  }
+
+  export async function read(key: string): Promise<Disposable> {
+    const lock = get(key)
+
+    return new Promise((resolve) => {
+      if (!lock.writer && lock.waitingWriters.length === 0) {
+        lock.readers++
+        resolve({
+          [Symbol.dispose]: () => {
+            lock.readers--
+            process(key)
+          },
+        })
+      } else {
+        lock.waitingReaders.push(() => {
+          lock.readers++
+          resolve({
+            [Symbol.dispose]: () => {
+              lock.readers--
+              process(key)
+            },
+          })
+        })
+      }
+    })
+  }
+
+  export async function write(key: string): Promise<Disposable> {
+    const lock = get(key)
+
+    return new Promise((resolve) => {
+      if (!lock.writer && lock.readers === 0) {
+        lock.writer = true
+        resolve({
+          [Symbol.dispose]: () => {
+            lock.writer = false
+            process(key)
+          },
+        })
+      } else {
+        lock.waitingWriters.push(() => {
+          lock.writer = true
+          resolve({
+            [Symbol.dispose]: () => {
+              lock.writer = false
+              process(key)
+            },
+          })
+        })
+      }
+    })
+  }
+}

package/src/util/log.ts

@@ -0,0 +1,180 @@
+import path from "path"
+import fs from "fs/promises"
+import { Global } from "../global"
+import z from "zod"
+
+export namespace Log {
+  export const Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" })
+  export type Level = z.infer<typeof Level>
+
+  const levelPriority: Record<Level, number> = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+  }
+
+  let level: Level = "INFO"
+
+  function shouldLog(input: Level): boolean {
+    return levelPriority[input] >= levelPriority[level]
+  }
+
+  export type Logger = {
+    debug(message?: any, extra?: Record<string, any>): void
+    info(message?: any, extra?: Record<string, any>): void
+    error(message?: any, extra?: Record<string, any>): void
+    warn(message?: any, extra?: Record<string, any>): void
+    tag(key: string, value: string): Logger
+    clone(): Logger
+    time(
+      message: string,
+      extra?: Record<string, any>,
+    ): {
+      stop(): void
+      [Symbol.dispose](): void
+    }
+  }
+
+  const loggers = new Map<string, Logger>()
+
+  export const Default = create({ service: "default" })
+
+  export interface Options {
+    print: boolean
+    dev?: boolean
+    level?: Level
+  }
+
+  let logpath = ""
+  export function file() {
+    return logpath
+  }
+  let write = (msg: any) => {
+    process.stderr.write(msg)
+    return msg.length
+  }
+
+  export async function init(options: Options) {
+    if (options.level) level = options.level
+    cleanup(Global.Path.log)
+    if (options.print) return
+    logpath = path.join(
+      Global.Path.log,
+      options.dev ? "dev.log" : new Date().toISOString().split(".")[0].replace(/:/g, "") + ".log",
+    )
+    const logfile = Bun.file(logpath)
+    await fs.truncate(logpath).catch(() => {})
+    const writer = logfile.writer()
+    write = async (msg: any) => {
+      const num = writer.write(msg)
+      writer.flush()
+      return num
+    }
+  }
+
+  async function cleanup(dir: string) {
+    const glob = new Bun.Glob("????-??-??T??????.log")
+    const files = await Array.fromAsync(
+      glob.scan({
+        cwd: dir,
+        absolute: true,
+      }),
+    )
+    if (files.length <= 5) return
+
+    const filesToDelete = files.slice(0, -10)
+    await Promise.all(filesToDelete.map((file) => fs.unlink(file).catch(() => {})))
+  }
+
+  function formatError(error: Error, depth = 0): string {
+    const result = error.message
+    return error.cause instanceof Error && depth < 10
+      ? result + " Caused by: " + formatError(error.cause, depth + 1)
+      : result
+  }
+
+  let last = Date.now()
+  export function create(tags?: Record<string, any>) {
+    tags = tags || {}
+
+    const service = tags["service"]
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service)
+      if (cached) {
+        return cached
+      }
+    }
+
+    function build(message: any, extra?: Record<string, any>) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra,
+      })
+        .filter(([_, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => {
+          const prefix = `${key}=`
+          if (value instanceof Error) return prefix + formatError(value)
+          if (typeof value === "object") return prefix + JSON.stringify(value)
+          return prefix + value
+        })
+        .join(" ")
+      const next = new Date()
+      const diff = next.getTime() - last
+      last = next.getTime()
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n"
+    }
+    const result: Logger = {
+      debug(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("DEBUG")) {
+          write("DEBUG " + build(message, extra))
+        }
+      },
+      info(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("INFO")) {
+          write("INFO  " + build(message, extra))
+        }
+      },
+      error(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("ERROR")) {
+          write("ERROR " + build(message, extra))
+        }
+      },
+      warn(message?: any, extra?: Record<string, any>) {
+        if (shouldLog("WARN")) {
+          write("WARN  " + build(message, extra))
+        }
+      },
+      tag(key: string, value: string) {
+        if (tags) tags[key] = value
+        return result
+      },
+      clone() {
+        return Log.create({ ...tags })
+      },
+      time(message: string, extra?: Record<string, any>) {
+        const now = Date.now()
+        result.info(message, { status: "started", ...extra })
+        function stop() {
+          result.info(message, {
+            status: "completed",
+            duration: Date.now() - now,
+            ...extra,
+          })
+        }
+        return {
+          stop,
+          [Symbol.dispose]() {
+            stop()
+          },
+        }
+      },
+    }
+
+    if (service && typeof service === "string") {
+      loggers.set(service, result)
+    }
+
+    return result
+  }
+}

package/src/util/queue.ts

@@ -0,0 +1,32 @@
+export class AsyncQueue<T> implements AsyncIterable<T> {
+  private queue: T[] = []
+  private resolvers: ((value: T) => void)[] = []
+
+  push(item: T) {
+    const resolve = this.resolvers.shift()
+    if (resolve) resolve(item)
+    else this.queue.push(item)
+  }
+
+  async next(): Promise<T> {
+    if (this.queue.length > 0) return this.queue.shift()!
+    return new Promise((resolve) => this.resolvers.push(resolve))
+  }
+
+  async *[Symbol.asyncIterator]() {
+    while (true) yield await this.next()
+  }
+}
+
+export async function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>) {
+  const pending = [...items]
+  await Promise.all(
+    Array.from({ length: concurrency }, async () => {
+      while (true) {
+        const item = pending.pop()
+        if (item === undefined) return
+        await fn(item)
+      }
+    }),
+  )
+}

package/src/util/rpc.ts

@@ -0,0 +1,66 @@
+export namespace Rpc {
+  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)
+        }
+      },
+    }
+  }
+}

package/src/util/scrap.ts

@@ -0,0 +1,10 @@
+export const foo: string = "42"
+export const bar: number = 123
+
+export function dummyFunction(): void {
+  console.log("This is a dummy function")
+}
+
+export function randomHelper(): boolean {
+  return Math.random() > 0.5
+}

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,14 @@
+export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  let timeout: NodeJS.Timeout
+  return Promise.race([
+    promise.then((result) => {
+      clearTimeout(timeout)
+      return result
+    }),
+    new Promise<never>((_, reject) => {
+      timeout = setTimeout(() => {
+        reject(new Error(`Operation timed out after ${ms}ms`))
+      }, ms)
+    }),
+  ])
+}

package/src/util/token.ts

@@ -0,0 +1,7 @@
+export namespace Token {
+  const CHARS_PER_TOKEN = 4
+
+  export function estimate(input: string) {
+    return Math.max(0, Math.round((input || "").length / CHARS_PER_TOKEN))
+  }
+}

package/src/util/wildcard.ts

@@ -0,0 +1,56 @@
+import { sortBy, pipe } from "remeda"
+
+export namespace Wildcard {
+  export function match(str: string, pattern: string) {
+    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) + "( .*)?"
+    }
+
+    return new RegExp("^" + escaped + "$", "s").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
+  }
+}

package/src/worktree/index.ts

@@ -0,0 +1,217 @@
+import { $ } from "bun"
+import fs from "fs/promises"
+import path from "path"
+import z from "zod"
+import { NamedError } from "@codepro-ai/util/error"
+import { Global } from "../global"
+import { Instance } from "../project/instance"
+import { Project } from "../project/project"
+import { fn } from "../util/fn"
+import { Config } from "@/config/config"
+
+export namespace Worktree {
+  export const Info = z
+    .object({
+      name: z.string(),
+      branch: z.string(),
+      directory: z.string(),
+    })
+    .meta({
+      ref: "Worktree",
+    })
+
+  export type Info = z.infer<typeof Info>
+
+  export const CreateInput = z
+    .object({
+      name: z.string().optional(),
+      startCommand: z.string().optional(),
+    })
+    .meta({
+      ref: "WorktreeCreateInput",
+    })
+
+  export type CreateInput = z.infer<typeof CreateInput>
+
+  export const NotGitError = NamedError.create(
+    "WorktreeNotGitError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const NameGenerationFailedError = NamedError.create(
+    "WorktreeNameGenerationFailedError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const CreateFailedError = NamedError.create(
+    "WorktreeCreateFailedError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  export const StartCommandFailedError = NamedError.create(
+    "WorktreeStartCommandFailedError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+
+  const ADJECTIVES = [
+    "brave",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "curious",
+    "eager",
+    "gentle",
+    "glowing",
+    "happy",
+    "hidden",
+    "jolly",
+    "kind",
+    "lucky",
+    "mighty",
+    "misty",
+    "neon",
+    "nimble",
+    "playful",
+    "proud",
+    "quick",
+    "quiet",
+    "shiny",
+    "silent",
+    "stellar",
+    "sunny",
+    "swift",
+    "tidy",
+    "witty",
+  ] as const
+
+  const NOUNS = [
+    "cabin",
+    "cactus",
+    "canyon",
+    "circuit",
+    "comet",
+    "eagle",
+    "engine",
+    "falcon",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "knight",
+    "lagoon",
+    "meadow",
+    "moon",
+    "mountain",
+    "nebula",
+    "orchid",
+    "otter",
+    "panda",
+    "pixel",
+    "planet",
+    "river",
+    "rocket",
+    "sailor",
+    "squid",
+    "star",
+    "tiger",
+    "wizard",
+    "wolf",
+  ] as const
+
+  function pick<const T extends readonly string[]>(list: T) {
+    return list[Math.floor(Math.random() * list.length)]
+  }
+
+  function slug(input: string) {
+    return input
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+/, "")
+      .replace(/-+$/, "")
+  }
+
+  function randomName() {
+    return `${pick(ADJECTIVES)}-${pick(NOUNS)}`
+  }
+
+  async function exists(target: string) {
+    return fs
+      .stat(target)
+      .then(() => true)
+      .catch(() => false)
+  }
+
+  function outputText(input: Uint8Array | undefined) {
+    if (!input?.length) return ""
+    return new TextDecoder().decode(input).trim()
+  }
+
+  function errorText(result: { stdout?: Uint8Array; stderr?: Uint8Array }) {
+    return [outputText(result.stderr), outputText(result.stdout)].filter(Boolean).join("\n")
+  }
+
+  async function candidate(root: string, base?: string) {
+    for (const attempt of Array.from({ length: 26 }, (_, i) => i)) {
+      const name = base ? (attempt === 0 ? base : `${base}-${randomName()}`) : randomName()
+      const branch = `opencode/${name}`
+      const directory = path.join(root, name)
+
+      if (await exists(directory)) continue
+
+      const ref = `refs/heads/${branch}`
+      const branchCheck = await $`git show-ref --verify --quiet ${ref}`.quiet().nothrow().cwd(Instance.worktree)
+      if (branchCheck.exitCode === 0) continue
+
+      return Info.parse({ name, branch, directory })
+    }
+
+    throw new NameGenerationFailedError({ message: "Failed to generate a unique worktree name" })
+  }
+
+  async function runStartCommand(directory: string, cmd: string) {
+    if (process.platform === "win32") {
+      return $`cmd /c ${cmd}`.nothrow().cwd(directory)
+    }
+    return $`bash -lc ${cmd}`.nothrow().cwd(directory)
+  }
+
+  export const create = fn(CreateInput.optional(), async (input) => {
+    if (Instance.project.vcs !== "git") {
+      throw new NotGitError({ message: "Worktrees are only supported for git projects" })
+    }
+
+    const root = path.join(Global.Path.data, "worktree", Instance.project.id)
+    await fs.mkdir(root, { recursive: true })
+
+    const base = input?.name ? slug(input.name) : ""
+    const info = await candidate(root, base || undefined)
+
+    const created = await $`git worktree add -b ${info.branch} ${info.directory}`
+      .quiet()
+      .nothrow()
+      .cwd(Instance.worktree)
+    if (created.exitCode !== 0) {
+      throw new CreateFailedError({ message: errorText(created) || "Failed to create git worktree" })
+    }
+
+    const cmd = input?.startCommand?.trim()
+    if (!cmd) return info
+
+    const ran = await runStartCommand(info.directory, cmd)
+    if (ran.exitCode !== 0) {
+      throw new StartCommandFailedError({ message: errorText(ran) || "Worktree start command failed" })
+    }
+
+    return info
+  })
+}