@bloxystudios/bloxycode 1.0.1 → 1.0.4

package/src/bloxy/runner.ts

@@ -1,193 +0,0 @@
-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

@@ -1,246 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

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