@bloxystudios/bloxycode 1.0.0

package/src/agent/prompt/title.txt

@@ -0,0 +1,44 @@
+You are a title generator. You output ONLY a thread title. Nothing else.
+
+<task>
+Generate a brief title that would help the user find this conversation later.
+
+Follow all rules in <rules>
+Use the <examples> so you know what a good title looks like.
+Your output must be:
+- A single line
+- ≤50 characters
+- No explanations
+</task>
+
+<rules>
+- you MUST use the same language as the user message you are summarizing
+- Title must be grammatically correct and read naturally - no word salad
+- Never include tool names in the title (e.g. "read tool", "bash tool", "edit tool")
+- Focus on the main topic or question the user needs to retrieve
+- Vary your phrasing - avoid repetitive patterns like always starting with "Analyzing"
+- When a file is mentioned, focus on WHAT the user wants to do WITH the file, not just that they shared it
+- Keep exact: technical terms, numbers, filenames, HTTP codes
+- Remove: the, this, my, a, an
+- Never assume tech stack
+- Never use tools
+- NEVER respond to questions, just generate a title for the conversation
+- The title should NEVER include "summarizing" or "generating" when generating a title
+- DO NOT SAY YOU CANNOT GENERATE A TITLE OR COMPLAIN ABOUT THE INPUT
+- Always output something meaningful, even if the input is minimal.
+- If the user message is short or conversational (e.g. "hello", "lol", "what's up", "hey"):
+  → create a title that reflects the user's tone or intent (such as Greeting, Quick check-in, Light chat, Intro message, etc.)
+</rules>
+
+<examples>
+"debug 500 errors in production" → Debugging production 500 errors
+"refactor user service" → Refactoring user service
+"why is app.js failing" → app.js failure investigation
+"implement rate limiting" → Rate limiting implementation
+"how do I connect postgres to my API" → Postgres API connection
+"best practices for React hooks" → React hooks best practices
+"@src/auth.ts can you add refresh token support" → Auth refresh token support
+"@utils/parser.ts this is broken" → Parser bug fix
+"look at @config.json" → Config review
+"@App.tsx add dark mode toggle" → Dark mode toggle in App
+</examples>

package/src/auth/index.ts

@@ -0,0 +1,73 @@
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import z from "zod"
+
+export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
+
+export namespace Auth {
+  export const Oauth = z
+    .object({
+      type: z.literal("oauth"),
+      refresh: z.string(),
+      access: z.string(),
+      expires: z.number(),
+      accountId: z.string().optional(),
+      enterpriseUrl: z.string().optional(),
+    })
+    .meta({ ref: "OAuth" })
+
+  export const Api = z
+    .object({
+      type: z.literal("api"),
+      key: z.string(),
+    })
+    .meta({ ref: "ApiAuth" })
+
+  export const WellKnown = z
+    .object({
+      type: z.literal("wellknown"),
+      key: z.string(),
+      token: z.string(),
+    })
+    .meta({ ref: "WellKnownAuth" })
+
+  export const Info = z.discriminatedUnion("type", [Oauth, Api, WellKnown]).meta({ ref: "Auth" })
+  export type Info = z.infer<typeof Info>
+
+  const filepath = path.join(Global.Path.data, "auth.json")
+
+  export async function get(providerID: string) {
+    const auth = await all()
+    return auth[providerID]
+  }
+
+  export async function all(): Promise<Record<string, Info>> {
+    const file = Bun.file(filepath)
+    const data = await file.json().catch(() => ({}) as Record<string, unknown>)
+    return Object.entries(data).reduce(
+      (acc, [key, value]) => {
+        const parsed = Info.safeParse(value)
+        if (!parsed.success) return acc
+        acc[key] = parsed.data
+        return acc
+      },
+      {} as Record<string, Info>,
+    )
+  }
+
+  export async function set(key: string, info: Info) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    await Bun.write(file, JSON.stringify({ ...data, [key]: info }, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+
+  export async function remove(key: string) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    delete data[key]
+    await Bun.write(file, JSON.stringify(data, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+}

package/src/bloxy/event.ts

@@ -0,0 +1,41 @@
+import z from "zod"
+import { BusEvent } from "../bus/bus-event"
+
+export namespace BloxyEvent {
+  export const TaskComplete = BusEvent.define(
+    "bloxy.task.complete",
+    z.object({
+      sessionID: z.string(),
+      taskId: z.string(),
+      summary: z.string().optional(),
+    })
+  )
+
+  export const TaskFailed = BusEvent.define(
+    "bloxy.task.failed",
+    z.object({
+      sessionID: z.string(),
+      taskId: z.string(),
+      error: z.string().optional(),
+    })
+  )
+
+  export const SessionStart = BusEvent.define(
+    "bloxy.session.start",
+    z.object({
+      sessionID: z.string(),
+      prdPath: z.string(),
+      taskCount: z.number(),
+    })
+  )
+
+  export const SessionComplete = BusEvent.define(
+    "bloxy.session.complete",
+    z.object({
+      sessionID: z.string(),
+      completed: z.number(),
+      failed: z.number(),
+      total: z.number(),
+    })
+  )
+}

package/src/bloxy/index.ts

@@ -0,0 +1,5 @@
+export { BloxyState } from "./state"
+export { BloxyParser } from "./parser"
+export { BloxyPrompt } from "./prompt"
+export { BloxyRunner } from "./runner"
+export { BloxyEvent } from "./event"

package/src/bloxy/parser.ts

@@ -0,0 +1,263 @@
+import fs from "fs/promises"
+import path from "path"
+import { BloxyState } from "./state"
+import { Log } from "../util/log"
+
+export namespace BloxyParser {
+  const log = Log.create({ service: "bloxy.parser" })
+
+  export interface ParseOptions {
+    worktree: string
+    prdPath: string
+    config?: Partial<BloxyState.Config>
+  }
+
+  export interface ParseResult {
+    tasks: BloxyState.Task[]
+    config: BloxyState.Config
+    prdPath: string
+  }
+
+  /**
+   * Parse a PRD file and extract tasks
+   * Supports markdown with checkbox format: `- [ ] task title`
+   */
+  export async function parse(options: ParseOptions): Promise<ParseResult> {
+    const filepath = path.isAbsolute(options.prdPath)
+      ? options.prdPath
+      : path.join(options.worktree, options.prdPath)
+
+    const content = await fs.readFile(filepath, "utf-8")
+    const ext = path.extname(filepath).toLowerCase()
+
+    let tasks: BloxyState.Task[]
+
+    if (ext === ".yaml" || ext === ".yml") {
+      tasks = parseYaml(content)
+    } else if (ext === ".json") {
+      tasks = parseJson(content)
+    } else {
+      // Default to markdown
+      tasks = parseMarkdown(content)
+    }
+
+    log.info("Parsed PRD", { path: filepath, tasks: tasks.length })
+
+    return {
+      tasks,
+      config: BloxyState.Config.parse(options.config ?? {}),
+      prdPath: filepath,
+    }
+  }
+
+  /**
+   * Parse markdown PRD with checkbox format
+   * Supports:
+   * - [ ] task title (pending)
+   * - [x] completed task (skipped)
+   * - [~] deferred task (included but skipped during execution)
+   * ## Task: title
+   */
+  function parseMarkdown(content: string): BloxyState.Task[] {
+    const tasks: BloxyState.Task[] = []
+    const lines = content.split("\n")
+
+    let currentTask: Partial<BloxyState.Task> | null = null
+    let bodyLines: string[] = []
+    let taskIndex = 0
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]
+
+      // Check for checkbox format: - [ ] task, - [x] task, or - [~] task
+      const checkboxMatch = line.match(/^[-*]\s*\[([ xX~])\]\s*(.+)$/)
+      if (checkboxMatch) {
+        // Save previous task
+        if (currentTask) {
+          currentTask.body = bodyLines.join("\n").trim() || undefined
+          tasks.push(BloxyState.Task.parse(currentTask))
+        }
+
+        const marker = checkboxMatch[1].toLowerCase()
+        const title = checkboxMatch[2].trim()
+
+        if (marker === "x") {
+          // Completed task - skip entirely
+          currentTask = null
+          bodyLines = []
+        } else if (marker === "~") {
+          // Deferred task - include but mark as deferred
+          taskIndex++
+          currentTask = {
+            id: `task-${taskIndex}`,
+            title,
+            status: "deferred",
+            attempts: 0,
+            time: {},
+          }
+          bodyLines = []
+        } else {
+          // Pending task
+          taskIndex++
+          currentTask = {
+            id: `task-${taskIndex}`,
+            title,
+            status: "pending",
+            attempts: 0,
+            time: {},
+          }
+          bodyLines = []
+        }
+        continue
+      }
+
+      // Check for header format: ## Task: title or ### title
+      const headerMatch = line.match(/^#{1,3}\s*(?:Task\s*[:.]?\s*)?(.+)$/)
+      if (headerMatch && !line.startsWith("####")) {
+        // Save previous task
+        if (currentTask) {
+          currentTask.body = bodyLines.join("\n").trim() || undefined
+          tasks.push(BloxyState.Task.parse(currentTask))
+        }
+
+        // Check if this header looks like a task (not just a section like "Overview")
+        const title = headerMatch[1].trim()
+        const skipHeaders = ["overview", "summary", "introduction", "tasks", "context", "requirements", "notes"]
+        if (skipHeaders.some(h => title.toLowerCase() === h)) {
+          currentTask = null
+          bodyLines = []
+          continue
+        }
+
+        taskIndex++
+        currentTask = {
+          id: `task-${taskIndex}`,
+          title,
+          status: "pending",
+          attempts: 0,
+          time: {},
+        }
+        bodyLines = []
+        continue
+      }
+
+      // Accumulate body content for current task
+      if (currentTask) {
+        bodyLines.push(line)
+      }
+    }
+
+    // Save last task
+    if (currentTask) {
+      currentTask.body = bodyLines.join("\n").trim() || undefined
+      tasks.push(BloxyState.Task.parse(currentTask))
+    }
+
+    return tasks
+  }
+
+  /**
+   * Parse YAML PRD format
+   * Expected format:
+   * tasks:
+   *   - title: "task title"
+   *     body: "optional description"
+   */
+  function parseYaml(content: string): BloxyState.Task[] {
+    // Simple YAML parser for task lists
+    // For full YAML support, could use a library
+    const tasks: BloxyState.Task[] = []
+
+    // Match tasks array entries
+    const taskRegex = /^\s*-\s*title:\s*["']?(.+?)["']?\s*$/gm
+    let match
+    let index = 0
+
+    while ((match = taskRegex.exec(content)) !== null) {
+      index++
+      tasks.push(BloxyState.Task.parse({
+        id: `task-${index}`,
+        title: match[1].trim(),
+        status: "pending",
+        attempts: 0,
+        time: {},
+      }))
+    }
+
+    return tasks
+  }
+
+  /**
+   * Parse JSON PRD format
+   * Expected format:
+   * {
+   *   "tasks": [
+   *     { "title": "task title", "body": "optional" }
+   *   ]
+   * }
+   */
+  function parseJson(content: string): BloxyState.Task[] {
+    const data = JSON.parse(content)
+    const tasks: BloxyState.Task[] = []
+
+    if (!data.tasks || !Array.isArray(data.tasks)) {
+      throw new Error("JSON PRD must have a 'tasks' array")
+    }
+
+    data.tasks.forEach((item: { title?: string; body?: string; completed?: boolean }, index: number) => {
+      if (!item.title) return
+      if (item.completed) return // Skip completed tasks
+
+      tasks.push(BloxyState.Task.parse({
+        id: `task-${index + 1}`,
+        title: item.title,
+        body: item.body,
+        status: "pending",
+        attempts: 0,
+        time: {},
+      }))
+    })
+
+    return tasks
+  }
+
+  /**
+   * Create a BloxyState.Session from parsed results
+   */
+  export function createSession(result: ParseResult): BloxyState.Session {
+    return BloxyState.Session.parse({
+      tasks: result.tasks,
+      currentTaskIndex: 0,
+      prdPath: result.prdPath,
+      config: result.config,
+      status: "idle",
+      time: {},
+    })
+  }
+
+  /**
+   * Update the original PRD file to mark a task as complete
+   */
+  export async function markTaskInFile(filepath: string, taskTitle: string): Promise<void> {
+    try {
+      const content = await fs.readFile(filepath, "utf-8")
+      const ext = path.extname(filepath).toLowerCase()
+
+      if (ext === ".md") {
+        // Replace - [ ] with - [x] for the matching task
+        const escaped = taskTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        const updated = content.replace(
+          new RegExp(`^([-*]\\s*)\\[[ ]\\](\\s*${escaped})`, "m"),
+          "$1[x]$2"
+        )
+        if (updated !== content) {
+          await fs.writeFile(filepath, updated)
+          log.info("Marked task complete in PRD", { task: taskTitle })
+        }
+      }
+      // YAML and JSON don't have built-in completion markers in the same way
+    } catch (e) {
+      log.error("Failed to update PRD file", { error: e })
+    }
+  }
+}

package/src/bloxy/prompt.ts

@@ -0,0 +1,121 @@
+import { BloxyState } from "./state"
+
+export namespace BloxyPrompt {
+  /**
+   * Build the task context to inject into the session
+   */
+  export function buildTaskContext(session: BloxyState.Session, task: BloxyState.Task): string {
+    const completed = BloxyState.countCompleted(session)
+    const total = session.tasks.length
+    const remaining = BloxyState.countRemaining(session)
+
+    const parts: string[] = []
+
+    parts.push("## Bloxy Autonomous Mode Active")
+    parts.push("")
+    parts.push(`**Progress**: Task ${completed + 1} of ${total} (${remaining} remaining)`)
+    parts.push("")
+    parts.push("---")
+    parts.push("")
+    parts.push(`## Current Task: ${task.title}`)
+
+    if (task.body) {
+      parts.push("")
+      parts.push(task.body)
+    }
+
+    parts.push("")
+    parts.push("---")
+    parts.push("")
+    parts.push("## Instructions")
+    parts.push("")
+    parts.push("1. **Implement** the task described above completely")
+
+    let step = 2
+    if (session.config.runTests && session.config.testCommand) {
+      parts.push(`${step}. **Test** by running: \`${session.config.testCommand}\``)
+      step++
+    }
+
+    if (session.config.lintCommand) {
+      parts.push(`${step}. **Lint** by running: \`${session.config.lintCommand}\``)
+      step++
+    }
+
+    if (session.config.autoCommit) {
+      parts.push(`${step}. **Commit** your changes with a descriptive message`)
+      step++
+    }
+
+    parts.push(`${step}. **Signal completion** using the \`bloxy_control\` tool with action "task_complete"`)
+
+    parts.push("")
+    parts.push("## Important")
+    parts.push("")
+    parts.push("- Focus ONLY on this task - do not work ahead")
+    parts.push("- Keep changes focused and minimal")
+    parts.push("- If you encounter an error you cannot resolve, use `bloxy_control` with action \"task_failed\"")
+    parts.push("- Do NOT modify the PRD file directly")
+
+    return parts.join("\n")
+  }
+
+  /**
+   * Build completion summary for the session
+   */
+  export function buildCompletionSummary(session: BloxyState.Session): string {
+    const completed = BloxyState.countCompleted(session)
+    const failed = BloxyState.countFailed(session)
+    const total = session.tasks.length
+
+    const parts: string[] = []
+
+    parts.push("## Bloxy Session Complete")
+    parts.push("")
+    parts.push(`**Results**: ${completed}/${total} tasks completed${failed > 0 ? `, ${failed} failed` : ""}`)
+    parts.push("")
+
+    if (completed > 0) {
+      parts.push("### Completed Tasks")
+      session.tasks.filter(t => t.status === "completed").forEach(t => {
+        parts.push(`- [x] ${t.title}${t.summary ? `: ${t.summary}` : ""}`)
+      })
+      parts.push("")
+    }
+
+    if (failed > 0) {
+      parts.push("### Failed Tasks")
+      session.tasks.filter(t => t.status === "failed").forEach(t => {
+        parts.push(`- [ ] ${t.title}${t.error ? `: ${t.error}` : ""}`)
+      })
+      parts.push("")
+    }
+
+    const duration = session.time.completed && session.time.started
+      ? Math.round((session.time.completed - session.time.started) / 1000)
+      : 0
+
+    if (duration > 0) {
+      const minutes = Math.floor(duration / 60)
+      const seconds = duration % 60
+      parts.push(`**Duration**: ${minutes > 0 ? `${minutes}m ` : ""}${seconds}s`)
+    }
+
+    return parts.join("\n")
+  }
+
+  /**
+   * Build the status display for the TUI
+   */
+  export function buildStatusLine(session: BloxyState.Session): string {
+    const task = BloxyState.getCurrentTask(session)
+    if (!task) {
+      return BloxyState.formatProgress(session)
+    }
+
+    const completed = BloxyState.countCompleted(session)
+    const total = session.tasks.length
+
+    return `[${completed + 1}/${total}] ${task.title}`
+  }
+}