@bloxystudios/bloxycode 1.0.2 → 1.0.5

package/src/agent/prompt/title.txt

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

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

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

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

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

@@ -1,121 +0,0 @@
-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}`
-  }
-}