@bloxystudios/bloxycode 1.0.0

package/src/bloxy/runner.ts

@@ -0,0 +1,193 @@
+import { Instance } from "../project/instance"
+import { Log } from "../util/log"
+import { Bus } from "../bus"
+import { BloxyState } from "./state"
+import { BloxyParser } from "./parser"
+import { BloxyPrompt } from "./prompt"
+import { BloxyEvent } from "./event"
+
+export namespace BloxyRunner {
+  const log = Log.create({ service: "bloxy.runner" })
+
+  export interface StartOptions {
+    prdPath: string
+    sessionID: string
+    config?: Partial<BloxyState.Config>
+  }
+
+  /**
+   * Start a new Bloxy session by parsing the PRD and initializing state
+   */
+  export async function start(options: StartOptions): Promise<BloxyState.Session> {
+    const worktree = Instance.worktree
+
+    // Check for existing session
+    const existing = await BloxyState.load(worktree)
+    if (existing && !BloxyState.isComplete(existing)) {
+      log.info("Resuming existing session", { tasks: existing.tasks.length, current: existing.currentTaskIndex })
+      return existing
+    }
+
+    // Parse PRD and create new session
+    const result = await BloxyParser.parse({
+      worktree,
+      prdPath: options.prdPath,
+      config: options.config,
+    })
+
+    if (result.tasks.length === 0) {
+      throw new Error(`No tasks found in PRD file: ${options.prdPath}`)
+    }
+
+    const session = BloxyParser.createSession(result)
+    session.status = "running"
+    session.time.started = Date.now()
+
+    await BloxyState.save(worktree, session)
+
+    // Publish start event
+    await Bus.publish(BloxyEvent.SessionStart, {
+      sessionID: options.sessionID,
+      prdPath: result.prdPath,
+      taskCount: result.tasks.length,
+    })
+
+    log.info("Started Bloxy session", { tasks: session.tasks.length, prdPath: result.prdPath })
+
+    return session
+  }
+
+  /**
+   * Get the context message to inject for the current task
+   */
+  export async function getTaskContext(sessionID: string): Promise<string | null> {
+    const worktree = Instance.worktree
+    const session = await BloxyState.load(worktree)
+
+    if (!session) {
+      return null
+    }
+
+    if (BloxyState.isComplete(session)) {
+      return BloxyPrompt.buildCompletionSummary(session)
+    }
+
+    const task = BloxyState.getCurrentTask(session)
+    if (!task) {
+      return null
+    }
+
+    // Mark task as in progress if it's pending
+    if (task.status === "pending") {
+      await BloxyState.markInProgress(worktree, session, task.id)
+    }
+
+    return BloxyPrompt.buildTaskContext(session, task)
+  }
+
+  /**
+   * Check if the session should continue to the next task
+   */
+  export async function shouldContinue(): Promise<boolean> {
+    const worktree = Instance.worktree
+    const session = await BloxyState.load(worktree)
+
+    if (!session) {
+      return false
+    }
+
+    return BloxyState.shouldContinue(session)
+  }
+
+  /**
+   * Complete the session and clean up
+   */
+  export async function complete(sessionID: string): Promise<void> {
+    const worktree = Instance.worktree
+    const session = await BloxyState.load(worktree)
+
+    if (!session) {
+      return
+    }
+
+    const completed = BloxyState.countCompleted(session)
+    const failed = BloxyState.countFailed(session)
+    const total = session.tasks.length
+
+    // Publish completion event
+    await Bus.publish(BloxyEvent.SessionComplete, {
+      sessionID,
+      completed,
+      failed,
+      total,
+    })
+
+    log.info("Bloxy session complete", { completed, failed, total })
+
+    // Update PRD file with completion markers
+    for (const task of session.tasks) {
+      if (task.status === "completed") {
+        await BloxyParser.markTaskInFile(session.prdPath, task.title)
+      }
+    }
+  }
+
+  /**
+   * Pause the current session
+   */
+  export async function pause(): Promise<void> {
+    const worktree = Instance.worktree
+    const session = await BloxyState.load(worktree)
+
+    if (session) {
+      await BloxyState.pause(worktree, session)
+    }
+  }
+
+  /**
+   * Resume a paused session
+   */
+  export async function resume(): Promise<void> {
+    const worktree = Instance.worktree
+    const session = await BloxyState.load(worktree)
+
+    if (session) {
+      await BloxyState.resume(worktree, session)
+    }
+  }
+
+  /**
+   * Stop the session completely
+   */
+  export async function stop(): Promise<void> {
+    const worktree = Instance.worktree
+    await BloxyState.remove(worktree)
+    log.info("Bloxy session stopped and removed")
+  }
+
+  /**
+   * Get the current status for display
+   */
+  export async function getStatus(): Promise<{
+    active: boolean
+    session: BloxyState.Session | null
+    statusLine: string
+  }> {
+    const worktree = Instance.worktree
+    const session = await BloxyState.load(worktree)
+
+    if (!session) {
+      return {
+        active: false,
+        session: null,
+        statusLine: "No active Bloxy session",
+      }
+    }
+
+    return {
+      active: !BloxyState.isComplete(session),
+      session,
+      statusLine: BloxyPrompt.buildStatusLine(session),
+    }
+  }
+}

package/src/bloxy/state.ts

@@ -0,0 +1,246 @@
+import z from "zod"
+import path from "path"
+import fs from "fs/promises"
+import { Log } from "../util/log"
+
+export namespace BloxyState {
+  const log = Log.create({ service: "bloxy.state" })
+
+  export const Task = z.object({
+    id: z.string(),
+    title: z.string(),
+    body: z.string().optional(),
+    status: z.enum(["pending", "in_progress", "completed", "failed", "deferred"]),
+    attempts: z.number().default(0),
+    error: z.string().optional(),
+    summary: z.string().optional(),
+    time: z.object({
+      started: z.number().optional(),
+      completed: z.number().optional(),
+    }).default({}),
+  })
+  export type Task = z.infer<typeof Task>
+
+  export const Config = z.object({
+    maxRetries: z.number().default(3),
+    retryDelay: z.number().default(5000),
+    runTests: z.boolean().default(true),
+    testCommand: z.string().optional(),
+    lintCommand: z.string().optional(),
+    stopOnError: z.boolean().default(false),
+    autoCommit: z.boolean().default(false),
+  })
+  export type Config = z.infer<typeof Config>
+
+  export const Session = z.object({
+    tasks: z.array(Task),
+    currentTaskIndex: z.number().default(0),
+    prdPath: z.string(),
+    config: Config,
+    status: z.enum(["idle", "running", "paused", "completed", "failed"]).default("idle"),
+    time: z.object({
+      started: z.number().optional(),
+      completed: z.number().optional(),
+    }).default({}),
+  })
+  export type Session = z.infer<typeof Session>
+
+  const STATE_FILE = ".bloxycode/bloxy-state.json"
+
+  function statePath(worktree: string): string {
+    return path.join(worktree, STATE_FILE)
+  }
+
+  export async function load(worktree: string): Promise<Session | null> {
+    const filepath = statePath(worktree)
+    try {
+      const content = await fs.readFile(filepath, "utf-8")
+      const data = JSON.parse(content)
+      return Session.parse(data)
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code === "ENOENT") {
+        return null
+      }
+      log.error("Failed to load bloxy state", { error: e })
+      return null
+    }
+  }
+
+  export async function save(worktree: string, session: Session): Promise<void> {
+    const filepath = statePath(worktree)
+    const dir = path.dirname(filepath)
+    await fs.mkdir(dir, { recursive: true })
+    await fs.writeFile(filepath, JSON.stringify(session, null, 2))
+    log.info("Saved bloxy state", { tasks: session.tasks.length, current: session.currentTaskIndex })
+  }
+
+  export async function remove(worktree: string): Promise<void> {
+    const filepath = statePath(worktree)
+    try {
+      await fs.unlink(filepath)
+      log.info("Removed bloxy state")
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
+        log.error("Failed to remove bloxy state", { error: e })
+      }
+    }
+  }
+
+  export function getCurrentTask(session: Session): Task | null {
+    if (session.currentTaskIndex >= session.tasks.length) {
+      return null
+    }
+    return session.tasks[session.currentTaskIndex]
+  }
+
+  export function getNextPendingTask(session: Session): Task | null {
+    for (let i = session.currentTaskIndex; i < session.tasks.length; i++) {
+      const status = session.tasks[i].status
+      if (status === "pending" || status === "in_progress") {
+        return session.tasks[i]
+      }
+    }
+    return null
+  }
+
+  export function getNextActionableTask(session: Session, skipFailed = false): Task | null {
+    for (let i = 0; i < session.tasks.length; i++) {
+      const status = session.tasks[i].status
+      if (status === "pending" || status === "in_progress") {
+        return session.tasks[i]
+      }
+      if (!skipFailed && status === "failed") {
+        return session.tasks[i]
+      }
+    }
+    return null
+  }
+
+  export function countRemaining(session: Session): number {
+    return session.tasks.filter(t => t.status === "pending" || t.status === "in_progress").length
+  }
+
+  export function countCompleted(session: Session): number {
+    return session.tasks.filter(t => t.status === "completed").length
+  }
+
+  export function countFailed(session: Session): number {
+    return session.tasks.filter(t => t.status === "failed").length
+  }
+
+  export function countDeferred(session: Session): number {
+    return session.tasks.filter(t => t.status === "deferred").length
+  }
+
+  export async function markInProgress(worktree: string, session: Session, taskId: string): Promise<Session> {
+    const task = session.tasks.find(t => t.id === taskId)
+    if (task) {
+      task.status = "in_progress"
+      task.time.started = Date.now()
+      task.attempts += 1
+    }
+    session.status = "running"
+    await save(worktree, session)
+    return session
+  }
+
+  export async function markComplete(worktree: string, session: Session, taskId: string, summary?: string): Promise<Session> {
+    const task = session.tasks.find(t => t.id === taskId)
+    if (task) {
+      task.status = "completed"
+      task.time.completed = Date.now()
+      if (summary) task.summary = summary
+    }
+
+    // Find next pending task index
+    const nextIndex = session.tasks.findIndex((t, i) =>
+      i > session.currentTaskIndex && (t.status === "pending" || t.status === "in_progress")
+    )
+
+    if (nextIndex === -1) {
+      // All tasks done
+      session.currentTaskIndex = session.tasks.length
+      const allCompleted = session.tasks.every(t => t.status === "completed")
+      session.status = allCompleted ? "completed" : "failed"
+      session.time.completed = Date.now()
+    } else {
+      session.currentTaskIndex = nextIndex
+    }
+
+    await save(worktree, session)
+    log.info("Task completed", { taskId, remaining: countRemaining(session) })
+    return session
+  }
+
+  export async function markFailed(worktree: string, session: Session, taskId: string, error?: string): Promise<Session> {
+    const task = session.tasks.find(t => t.id === taskId)
+    if (task) {
+      task.time.completed = Date.now()
+      if (error) task.error = error
+
+      // Check if we should retry
+      if (task.attempts < session.config.maxRetries) {
+        task.status = "pending" // Reset to pending for retry
+        log.info("Task failed, will retry", { taskId, attempts: task.attempts, maxRetries: session.config.maxRetries })
+      } else {
+        task.status = "failed"
+        log.error("Task failed after max retries", { taskId, error })
+
+        if (session.config.stopOnError) {
+          session.status = "failed"
+          session.time.completed = Date.now()
+        } else {
+          // Move to next task
+          const nextIndex = session.tasks.findIndex((t, i) =>
+            i > session.currentTaskIndex && t.status === "pending"
+          )
+          if (nextIndex === -1) {
+            session.status = "completed"
+            session.time.completed = Date.now()
+          } else {
+            session.currentTaskIndex = nextIndex
+          }
+        }
+      }
+    }
+
+    await save(worktree, session)
+    return session
+  }
+
+  export async function pause(worktree: string, session: Session): Promise<Session> {
+    session.status = "paused"
+    await save(worktree, session)
+    log.info("Bloxy session paused")
+    return session
+  }
+
+  export async function resume(worktree: string, session: Session): Promise<Session> {
+    if (session.status === "paused") {
+      session.status = "running"
+      await save(worktree, session)
+      log.info("Bloxy session resumed")
+    }
+    return session
+  }
+
+  export function isComplete(session: Session): boolean {
+    return session.status === "completed" || session.status === "failed"
+  }
+
+  export function shouldContinue(session: Session): boolean {
+    return session.status === "running" && countRemaining(session) > 0
+  }
+
+  export function formatProgress(session: Session): string {
+    const completed = countCompleted(session)
+    const failed = countFailed(session)
+    const total = session.tasks.length
+    const current = getCurrentTask(session)
+
+    if (current) {
+      return `Task ${completed + 1}/${total}: ${current.title}${failed > 0 ? ` (${failed} failed)` : ""}`
+    }
+    return `${completed}/${total} tasks completed${failed > 0 ? `, ${failed} failed` : ""}`
+  }
+}

package/src/bun/index.ts

@@ -0,0 +1,134 @@
+import z from "zod"
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import { Filesystem } from "../util/filesystem"
+import { NamedError } from "@/util/error"
+import { readableStreamToText } from "bun"
+import { createRequire } from "module"
+import { Lock } from "../util/lock"
+
+export namespace BunProc {
+  const log = Log.create({ service: "bun" })
+  const req = createRequire(import.meta.url)
+
+  export async function run(cmd: string[], options?: Bun.SpawnOptions.OptionsObject<any, any, any>) {
+    log.info("running", {
+      cmd: [which(), ...cmd],
+      ...options,
+    })
+    const result = Bun.spawn([which(), ...cmd], {
+      ...options,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        ...options?.env,
+        BUN_BE_BUN: "1",
+      },
+    })
+    const code = await result.exited
+    const stdout = result.stdout
+      ? typeof result.stdout === "number"
+        ? result.stdout
+        : await readableStreamToText(result.stdout)
+      : undefined
+    const stderr = result.stderr
+      ? typeof result.stderr === "number"
+        ? result.stderr
+        : await readableStreamToText(result.stderr)
+      : undefined
+    log.info("done", {
+      code,
+      stdout,
+      stderr,
+    })
+    if (code !== 0) {
+      throw new Error(`Command failed with exit code ${result.exitCode}`)
+    }
+    return result
+  }
+
+  export function which() {
+    return process.execPath
+  }
+
+  export const InstallFailedError = NamedError.create(
+    "BunInstallFailedError",
+    z.object({
+      pkg: z.string(),
+      version: z.string(),
+    }),
+  )
+
+  export async function install(pkg: string, version = "latest") {
+    // Use lock to ensure only one install at a time
+    using _ = await Lock.write("bun-install")
+
+    const mod = path.join(Global.Path.cache, "node_modules", pkg)
+    const pkgjson = Bun.file(path.join(Global.Path.cache, "package.json"))
+    const parsed = await pkgjson.json().catch(async () => {
+      const result = { dependencies: {} }
+      await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2))
+      return result
+    })
+    const dependencies = parsed.dependencies ?? {}
+    if (!parsed.dependencies) parsed.dependencies = dependencies
+    const modExists = await Filesystem.exists(mod)
+    if (dependencies[pkg] === version && modExists) return mod
+
+    const proxied = !!(
+      process.env.HTTP_PROXY ||
+      process.env.HTTPS_PROXY ||
+      process.env.http_proxy ||
+      process.env.https_proxy
+    )
+
+    // Build command arguments
+    const args = [
+      "add",
+      "--force",
+      "--exact",
+      // TODO: get rid of this case (see: https://github.com/oven-sh/bun/issues/19936)
+      ...(proxied ? ["--no-cache"] : []),
+      "--cwd",
+      Global.Path.cache,
+      pkg + "@" + version,
+    ]
+
+    // Let Bun handle registry resolution:
+    // - If .npmrc files exist, Bun will use them automatically
+    // - If no .npmrc files exist, Bun will default to https://registry.npmjs.org
+    // - No need to pass --registry flag
+    log.info("installing package using Bun's default registry resolution", {
+      pkg,
+      version,
+    })
+
+    await BunProc.run(args, {
+      cwd: Global.Path.cache,
+    }).catch((e) => {
+      throw new InstallFailedError(
+        { pkg, version },
+        {
+          cause: e,
+        },
+      )
+    })
+
+    // Resolve actual version from installed package when using "latest"
+    // This ensures subsequent starts use the cached version until explicitly updated
+    let resolvedVersion = version
+    if (version === "latest") {
+      const installedPkgJson = Bun.file(path.join(mod, "package.json"))
+      const installedPkg = await installedPkgJson.json().catch(() => null)
+      if (installedPkg?.version) {
+        resolvedVersion = installedPkg.version
+      }
+    }
+
+    parsed.dependencies[pkg] = resolvedVersion
+    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2))
+    return mod
+  }
+}

package/src/bus/bus-event.ts

@@ -0,0 +1,43 @@
+import z from "zod"
+import type { ZodType } from "zod"
+import { Log } from "../util/log"
+
+export namespace BusEvent {
+  const log = Log.create({ service: "event" })
+
+  export type Definition = ReturnType<typeof define>
+
+  const registry = new Map<string, Definition>()
+
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+    const result = {
+      type,
+      properties,
+    }
+    registry.set(type, result)
+    return result
+  }
+
+  export function payloads() {
+    return z
+      .discriminatedUnion(
+        "type",
+        registry
+          .entries()
+          .map(([type, def]) => {
+            return z
+              .object({
+                type: z.literal(type),
+                properties: def.properties,
+              })
+              .meta({
+                ref: "Event" + "." + def.type,
+              })
+          })
+          .toArray() as any,
+      )
+      .meta({
+        ref: "Event",
+      })
+  }
+}

package/src/bus/global.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events"
+
+export const GlobalBus = new EventEmitter<{
+  event: [
+    {
+      directory?: string
+      payload: any
+    },
+  ]
+}>()