@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/start-work/context-info-builder.ts

@@ -1,319 +0,0 @@
-import { statSync } from "node:fs"
-import {
-  appendSessionId,
-  clearBoulderState,
-  createBoulderState,
-  findStrategistPlans,
-  getPlanName,
-  getPlanProgress,
-  readBoulderState,
-  writeBoulderState,
-} from "../../features/boulder-state"
-import { log } from "../../shared/logger"
-import { createWorktreeActiveBlock } from "./worktree-block"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { HOOK_NAME } from "./start-work-hook"
-
-function normalizePlanLookupValue(value: string): string {
-  return value
-    .trim()
-    .replace(/^["'`]+|["'`]+$/g, "")
-    .toLowerCase()
-    .replace(/[\s_]+/g, "-")
-    .replace(/[^\p{L}\p{N}-]+/gu, "-")
-    .replace(/-+/g, "-")
-    .replace(/^-+|-+$/g, "")
-}
-
-function findPlanByName(plans: string[], requestedName: string): string | null {
-  const lowerName = requestedName.toLowerCase()
-  const normalizedRequestedName = normalizePlanLookupValue(requestedName)
-  const exactMatch = plans.find((p) => getPlanName(p).toLowerCase() === lowerName)
-  if (exactMatch) return exactMatch
-  const normalizedExactMatch = plans.find((planPath) =>
-    normalizePlanLookupValue(getPlanName(planPath)) === normalizedRequestedName,
-  )
-  if (normalizedExactMatch) return normalizedExactMatch
-  const partialMatch = plans.find((p) => getPlanName(p).toLowerCase().includes(lowerName))
-  if (partialMatch) return partialMatch
-
-  const normalizedPartialMatch = plans.find((planPath) =>
-    normalizePlanLookupValue(getPlanName(planPath)).includes(normalizedRequestedName),
-  )
-  return normalizedPartialMatch || null
-}
-
-function buildAutoSelectedPlanContext(params: {
-  planPath: string
-  sessionId: string
-  timestamp: string
-  activeAgent: string
-  worktreePath: string | undefined
-  worktreeBlock: string
-  directory: string
-}): string {
-  const { planPath, sessionId, timestamp, activeAgent, worktreePath, worktreeBlock, directory } = params
-  const progress = getPlanProgress(planPath)
-  const newState = createBoulderState(planPath, sessionId, activeAgent, worktreePath)
-  writeBoulderState(directory, newState)
-
-  return `
-## Auto-Selected Plan
-
-**Plan**: ${getPlanName(planPath)}
-**Path**: ${planPath}
-**Progress**: ${progress.completed}/${progress.total} tasks
-**Session ID**: ${sessionId}
-**Started**: ${timestamp}
-${worktreeBlock}
-
-boulder.json has been created. Read the plan and begin execution.`
-}
-
-function buildMissingPlanContext(explicitPlanName: string, allPlans: string[]): string {
-  const incompletePlans = allPlans.filter((p) => !getPlanProgress(p).isComplete)
-  if (incompletePlans.length > 0) {
-    const planList = incompletePlans
-      .map((p, i) => {
-        const prog = getPlanProgress(p)
-        return `${i + 1}. [${getPlanName(p)}] - Progress: ${prog.completed}/${prog.total}`
-      })
-      .join("\n")
-
-    return `
-## Plan Not Found
-
-Could not find a plan matching "${explicitPlanName}".
-
-Available incomplete plans:
-${planList}
-
-Ask the user which plan to work on.`
-  }
-
-  return `
-## Plan Not Found
-
- Could not find a plan matching "${explicitPlanName}".
- No incomplete plans available. Create a new plan using the Strategist agent.`
-}
-
-function buildExplicitPlanContext(params: {
-  explicitPlanName: string
-  existingState: ReturnType<typeof readBoulderState>
-  sessionId: string
-  timestamp: string
-  activeAgent: string
-  worktreePath: string | undefined
-  worktreeBlock: string
-  directory: string
-}): string {
-  const { explicitPlanName, existingState, sessionId, timestamp, activeAgent, worktreePath, worktreeBlock, directory } = params
-  log(`[${HOOK_NAME}] Explicit plan name requested: ${explicitPlanName}`, { sessionID: sessionId })
-
-  const allPlans = findStrategistPlans(directory)
-  const matchedPlan = findPlanByName(allPlans, explicitPlanName)
-  if (!matchedPlan) {
-    return buildMissingPlanContext(explicitPlanName, allPlans)
-  }
-
-  const progress = getPlanProgress(matchedPlan)
-  if (progress.isComplete) {
-    return `
-## Plan Already Complete
-
- The requested plan "${getPlanName(matchedPlan)}" has been completed.
- All ${progress.total} tasks are done. Create a new plan using the Strategist agent.`
-  }
-
-  if (existingState) {
-    clearBoulderState(directory)
-  }
-
-  return buildAutoSelectedPlanContext({
-    planPath: matchedPlan,
-    sessionId,
-    timestamp,
-    activeAgent,
-    worktreePath,
-    worktreeBlock,
-    directory,
-  })
-}
-
-function buildExistingSessionContext(params: {
-  existingState: NonNullable<ReturnType<typeof readBoulderState>>
-  sessionId: string
-  activeAgent: string
-  worktreePath: string | undefined
-  worktreeBlock: string
-  directory: string
-}): string {
-  const { existingState, sessionId, activeAgent, worktreePath, worktreeBlock, directory } = params
-  const progress = getPlanProgress(existingState.active_plan)
-  if (progress.isComplete) {
-    return `
-## Previous Work Complete
-
-The previous plan (${existingState.plan_name}) has been completed.
-Looking for new plans...`
-  }
-
-  const effectiveWorktree = worktreePath ?? existingState.worktree_path
-  const sessionAlreadyTracked = existingState.session_ids.includes(sessionId)
-  const updatedSessions = sessionAlreadyTracked
-    ? existingState.session_ids
-    : [...existingState.session_ids, sessionId]
-  const shouldRewriteState = existingState.agent !== activeAgent || worktreePath !== undefined
-
-  if (shouldRewriteState) {
-    writeBoulderState(directory, {
-      ...existingState,
-      agent: activeAgent,
-      ...(worktreePath !== undefined ? { worktree_path: worktreePath } : {}),
-      session_ids: updatedSessions,
-    })
-  } else if (!sessionAlreadyTracked) {
-    appendSessionId(directory, sessionId)
-  }
-
-  const worktreeDisplay = effectiveWorktree
-    ? (worktreeBlock || createWorktreeActiveBlock(effectiveWorktree))
-    : worktreeBlock
-
-  return `
-## Active Work Session Found
-
-**Status**: RESUMING existing work
-**Plan**: ${existingState.plan_name}
-**Path**: ${existingState.active_plan}
-**Progress**: ${progress.completed}/${progress.total} tasks completed
-**Sessions**: ${existingState.session_ids.length + 1} (current session appended)
-**Started**: ${existingState.started_at}
-${worktreeDisplay}
-
-The current session (${sessionId}) has been added to session_ids.
-Read the plan file and continue from the first unchecked task.`
-}
-
-function shouldDiscoverPlans(
-  existingState: ReturnType<typeof readBoulderState>,
-  explicitPlanName: string | null,
-): boolean {
-  return (!existingState && !explicitPlanName)
-    || (existingState !== null && !explicitPlanName && getPlanProgress(existingState.active_plan).isComplete)
-}
-
-function buildPlanDiscoveryContext(params: {
-  contextInfo: string
-  sessionId: string
-  timestamp: string
-  activeAgent: string
-  worktreePath: string | undefined
-  worktreeBlock: string
-  directory: string
-}): string {
-  const { contextInfo, sessionId, timestamp, activeAgent, worktreePath, worktreeBlock, directory } = params
-  const plans = findStrategistPlans(directory)
-  const incompletePlans = plans.filter((p) => !getPlanProgress(p).isComplete)
-
-  if (plans.length === 0) {
-    return contextInfo + `
-## No Plans Found
-
- No Strategist plan files found in the .bob plans directory.
- Use the Strategist agent to create a work plan first.`
-  }
-
-  if (incompletePlans.length === 0) {
-    return contextInfo + `
-
-## All Plans Complete
-
- All ${plans.length} plan(s) are complete. Create a new plan using the Strategist agent.`
-  }
-
-  if (incompletePlans.length === 1) {
-    return contextInfo + buildAutoSelectedPlanContext({
-      planPath: incompletePlans[0],
-      sessionId,
-      timestamp,
-      activeAgent,
-      worktreePath,
-      worktreeBlock,
-      directory,
-    })
-  }
-
-  const planList = incompletePlans
-    .map((p, i) => {
-      const progress = getPlanProgress(p)
-      const modified = new Date(statSync(p).mtimeMs).toISOString()
-      return `${i + 1}. [${getPlanName(p)}] - Modified: ${modified} - Progress: ${progress.completed}/${progress.total}`
-    })
-    .join("\n")
-
-  return contextInfo + `
-
-<system-reminder>
-## Multiple Plans Found
-
-Current Time: ${timestamp}
-Session ID: ${sessionId}
-
-${planList}
-
-Ask the user which plan to work on. Present the options above and wait for their response.
-${worktreeBlock}
-</system-reminder>`
-}
-
-export function buildStartWorkContextInfo(params: {
-  ctx: PluginInput
-  explicitPlanName: string | null
-  existingState: ReturnType<typeof readBoulderState>
-  sessionId: string
-  timestamp: string
-  activeAgent: string
-  worktreePath: string | undefined
-  worktreeBlock: string
-}): string {
-  const { ctx, explicitPlanName, existingState, sessionId, timestamp, activeAgent, worktreePath, worktreeBlock } = params
-
-  let contextInfo = ""
-  if (explicitPlanName) {
-    contextInfo = buildExplicitPlanContext({
-      explicitPlanName,
-      existingState,
-      sessionId,
-      timestamp,
-      activeAgent,
-      worktreePath,
-      worktreeBlock,
-      directory: ctx.directory,
-    })
-  } else if (existingState) {
-    contextInfo = buildExistingSessionContext({
-      existingState,
-      sessionId,
-      activeAgent,
-      worktreePath,
-      worktreeBlock,
-      directory: ctx.directory,
-    })
-  }
-
-  if (shouldDiscoverPlans(existingState, explicitPlanName)) {
-    return buildPlanDiscoveryContext({
-      contextInfo,
-      sessionId,
-      timestamp,
-      activeAgent,
-      worktreePath,
-      worktreeBlock,
-      directory: ctx.directory,
-    })
-  }
-
-  return contextInfo
-}

package/src/hooks/start-work/index.ts

@@ -1,4 +0,0 @@
-export { HOOK_NAME, createStartWorkHook } from "./start-work-hook"
-export { detectWorktreePath, listWorktrees, parseWorktreeListPorcelain } from "./worktree-detector"
-export type { ParsedUserRequest } from "./parse-user-request"
-export { parseUserRequest } from "./parse-user-request"

package/src/hooks/start-work/parse-user-request.ts

@@ -1,32 +0,0 @@
-const KEYWORD_PATTERN = /\b(ultrawork|ulw)\b/gi
-const WORKTREE_FLAG_PATTERN = /--worktree(?:\s+(\S+))?/
-const WRAPPING_QUOTES_PATTERN = /^(["'`])([\s\S]*)\1$/
-
-export interface ParsedUserRequest {
-  planName: string | null
-  explicitWorktreePath: string | null
-}
-
-export function parseUserRequest(promptText: string): ParsedUserRequest {
-  const match = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i)
-  if (!match) return { planName: null, explicitWorktreePath: null }
-
-  let rawArg = match[1].trim()
-  if (!rawArg) return { planName: null, explicitWorktreePath: null }
-
-  const worktreeMatch = rawArg.match(WORKTREE_FLAG_PATTERN)
-  const explicitWorktreePath = worktreeMatch ? (worktreeMatch[1] ?? null) : null
-
-  if (worktreeMatch) {
-    rawArg = rawArg.replace(worktreeMatch[0], "").trim()
-  }
-
-  const cleanedArg = rawArg.replace(KEYWORD_PATTERN, "").trim()
-  const quotedPlanMatch = cleanedArg.match(WRAPPING_QUOTES_PATTERN)
-  const normalizedPlanName = quotedPlanMatch ? quotedPlanMatch[2].trim() : cleanedArg
-
-  return {
-    planName: normalizedPlanName || null,
-    explicitWorktreePath,
-  }
-}

package/src/hooks/start-work/start-work-hook.ts

@@ -1,135 +0,0 @@
-import { statSync } from "node:fs"
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  readBoulderState,
-  writeBoulderState,
-  appendSessionId,
-  findStrategistPlans,
-  getPlanProgress,
-  createBoulderState,
-  getPlanName,
-  clearBoulderState,
-} from "../../features/boulder-state"
-import { log } from "../../shared/logger"
-import {
-  isAgentRegistered,
-  resolveRegisteredAgentName,
-  updateSessionAgent,
-} from "../../features/claude-code-session-state"
-import { detectWorktreePath } from "./worktree-detector"
-import { parseUserRequest } from "./parse-user-request"
-import { buildStartWorkContextInfo } from "./context-info-builder"
-import { createWorktreeActiveBlock } from "./worktree-block"
-
-export const HOOK_NAME = "start-work" as const
-const START_WORK_TEMPLATE_MARKER = "You are starting a Bob work session."
-
-interface StartWorkHookInput {
-  sessionID: string
-  messageID?: string
-}
-
-interface StartWorkCommandExecuteBeforeInput {
-  sessionID: string
-  command: string
-  arguments: string
-}
-
-interface StartWorkHookOutput {
-  message?: Record<string, unknown>
-  parts: Array<{ type: string; text?: string }>
-}
-
-function resolveWorktreeContext(
-  explicitWorktreePath: string | null,
-): { worktreePath: string | undefined; block: string } {
-  if (explicitWorktreePath === null) {
-    return { worktreePath: undefined, block: "" }
-  }
-
-  const validatedPath = detectWorktreePath(explicitWorktreePath)
-  if (validatedPath) {
-    return { worktreePath: validatedPath, block: createWorktreeActiveBlock(validatedPath) }
-  }
-
-  return {
-    worktreePath: undefined,
-    block: `\n**Worktree** (needs setup): \`git worktree add ${explicitWorktreePath} <branch>\`, then add \`"worktree_path"\` to boulder.json`,
-  }
-}
-
-export function createStartWorkHook(ctx: PluginInput) {
-  const processStartWork = async (
-    input: StartWorkHookInput,
-    output: StartWorkHookOutput,
-  ): Promise<void> => {
-    const parts = output.parts
-    const promptText =
-      parts
-        ?.filter((p) => p.type === "text" && p.text)
-        .map((p) => p.text)
-        .join("\n")
-        .trim() || ""
-
-    if (
-      !promptText.includes("<session-context>")
-      || !promptText.includes(START_WORK_TEMPLATE_MARKER)
-    ) {
-      return
-    }
-
-    log(`[${HOOK_NAME}] Processing start-work command`, { sessionID: input.sessionID })
-    const activeAgent = isAgentRegistered("guard")
-      ? "guard"
-      : "bob"
-    updateSessionAgent(input.sessionID, activeAgent)
-    if (output.message) {
-      output.message["agent"] = resolveRegisteredAgentName(activeAgent) ?? activeAgent
-    }
-
-    const existingState = readBoulderState(ctx.directory)
-    const sessionId = input.sessionID
-    const timestamp = new Date().toISOString()
-
-    const { planName: explicitPlanName, explicitWorktreePath } = parseUserRequest(promptText)
-    const { worktreePath, block: worktreeBlock } = resolveWorktreeContext(explicitWorktreePath)
-
-    const contextInfo = buildStartWorkContextInfo({
-      ctx,
-      explicitPlanName,
-      existingState,
-      sessionId,
-      timestamp,
-      activeAgent,
-      worktreePath,
-      worktreeBlock,
-    })
-
-    const idx = output.parts.findIndex((p) => p.type === "text" && p.text)
-    if (idx >= 0 && output.parts[idx].text) {
-      output.parts[idx].text = output.parts[idx].text
-        .replace(/\$SESSION_ID/g, sessionId)
-        .replace(/\$TIMESTAMP/g, timestamp)
-
-      output.parts[idx].text += `\n\n---\n${contextInfo}`
-    }
-
-    log(`[${HOOK_NAME}] Context injected`, {
-      sessionID: input.sessionID,
-      hasExistingState: !!existingState,
-      worktreePath,
-    })
-  }
-
-  return {
-    "chat.message": async (input: StartWorkHookInput, output: StartWorkHookOutput): Promise<void> => {
-      await processStartWork(input, output)
-    },
-    "command.execute.before": async (
-      input: StartWorkCommandExecuteBeforeInput,
-      output: StartWorkHookOutput,
-    ): Promise<void> => {
-      await processStartWork(input, output)
-    },
-  }
-}

package/src/hooks/start-work/worktree-block.ts

@@ -1,11 +0,0 @@
-export function createWorktreeActiveBlock(worktreePath: string): string {
-  return `
-## Worktree Active
-
-**Worktree**: \`${worktreePath}\`
-
-**CRITICAL - DO NOT FORGET**: You are working inside a git worktree. ALL operations MUST be performed exclusively within this worktree directory.
-- Every file read, write, edit, and git operation MUST target paths under: \`${worktreePath}\`
-- When delegating tasks to subagents, you MUST include the worktree path in your delegation prompt so they also operate exclusively within the worktree
-- NEVER operate on the main repository directory - always use the worktree path above`
-}

package/src/hooks/start-work/worktree-detector.ts

@@ -1,77 +0,0 @@
-import { execFileSync } from "node:child_process"
-
-export type WorktreeEntry = {
-  path: string
-  branch: string | undefined
-  bare: boolean
-}
-
-export function parseWorktreeListPorcelain(output: string): WorktreeEntry[] {
-  const lines = output.split("\n").map((line) => line.trim())
-  const entries: WorktreeEntry[] = []
-  let current: Partial<WorktreeEntry> | undefined
-
-  for (const line of lines) {
-    if (!line) {
-      if (current?.path) {
-        entries.push({
-          path: current.path,
-          branch: current.branch,
-          bare: current.bare ?? false,
-        })
-      }
-      current = undefined
-      continue
-    }
-
-    if (line.startsWith("worktree ")) {
-      current = { path: line.slice("worktree ".length).trim() }
-      continue
-    }
-
-    if (!current) continue
-
-    if (line.startsWith("branch ")) {
-      current.branch = line.slice("branch ".length).trim().replace(/^refs\/heads\//, "")
-    } else if (line === "bare") {
-      current.bare = true
-    }
-  }
-
-  if (current?.path) {
-    entries.push({
-      path: current.path,
-      branch: current.branch,
-      bare: current.bare ?? false,
-    })
-  }
-
-  return entries
-}
-
-export function listWorktrees(directory: string): WorktreeEntry[] {
-  try {
-    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
-      cwd: directory,
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    })
-    return parseWorktreeListPorcelain(output)
-  } catch {
-    return []
-  }
-}
-
-export function detectWorktreePath(directory: string): string | null {
-  try {
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: directory,
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim()
-  } catch {
-    return null
-  }
-}

package/src/hooks/stop-continuation-guard/hook.ts

@@ -1,122 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { BackgroundManager } from "../../features/background-agent"
-
-import {
-  clearContinuationMarker,
-  setContinuationMarkerSource,
-} from "../../features/run-continuation-state"
-import { log } from "../../shared/logger"
-
-const HOOK_NAME = "stop-continuation-guard"
-
-type StopContinuationBackgroundManager = Pick<
-  BackgroundManager,
-  "getAllDescendantTasks" | "cancelTask"
->
-
-export interface StopContinuationGuard {
-  event: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
-  "chat.message": (input: { sessionID?: string }) => Promise<void>
-  stop: (sessionID: string) => void
-  isStopped: (sessionID: string) => boolean
-  clear: (sessionID: string) => void
-}
-
-export function createStopContinuationGuardHook(
-  ctx: PluginInput,
-  options?: {
-    backgroundManager?: StopContinuationBackgroundManager
-  }
-): StopContinuationGuard {
-  const stoppedSessions = new Set<string>()
-
-  const stop = (sessionID: string): void => {
-    stoppedSessions.add(sessionID)
-    setContinuationMarkerSource(ctx.directory, sessionID, "stop", "stopped", "continuation stopped")
-    log(`[${HOOK_NAME}] Continuation stopped for session`, { sessionID })
-
-    const backgroundManager = options?.backgroundManager
-    if (!backgroundManager) {
-      return
-    }
-
-    const cancellableTasks = backgroundManager
-      .getAllDescendantTasks(sessionID)
-      .filter((task) => task.status === "running" || task.status === "pending")
-
-    if (cancellableTasks.length === 0) {
-      return
-    }
-
-    void Promise.allSettled(
-      cancellableTasks.map(async (task) => {
-        await backgroundManager.cancelTask(task.id, {
-          source: "stop-continuation",
-          reason: "Continuation stopped via /stop-continuation",
-          abortSession: task.status === "running",
-          skipNotification: true,
-        })
-      })
-    ).then((results) => {
-      const cancelledCount = results.filter((result) => result.status === "fulfilled").length
-      const failedCount = results.length - cancelledCount
-      log(`[${HOOK_NAME}] Cancelled background tasks for stopped session`, {
-        sessionID,
-        cancelledCount,
-        failedCount,
-      })
-    })
-  }
-
-  const isStopped = (sessionID: string): boolean => {
-    return stoppedSessions.has(sessionID)
-  }
-
-  const clear = (sessionID: string): void => {
-    stoppedSessions.delete(sessionID)
-    setContinuationMarkerSource(ctx.directory, sessionID, "stop", "idle")
-    log(`[${HOOK_NAME}] Continuation guard cleared for session`, { sessionID })
-  }
-
-  const event = async ({
-    event,
-  }: {
-    event: { type: string; properties?: unknown }
-  }): Promise<void> => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        clear(sessionInfo.id)
-        clearContinuationMarker(ctx.directory, sessionInfo.id)
-        log(`[${HOOK_NAME}] Session deleted: cleaned up`, { sessionID: sessionInfo.id })
-      }
-    }
-  }
-
-  const chatMessage = async ({
-    sessionID,
-  }: {
-    sessionID?: string
-  }): Promise<void> => {
-    // Intentionally no-op: stop state should persist across user messages.
-    // Previously this cleared the stop on any new user message, but that caused
-    // /stop-continuation to be ineffective — the user's very next message
-    // (including normal chat) would re-enable continuation.
-    //
-    // Stop state is now only cleared by:
-    // 1. /start-work (or /ulw-loop, /ralph-loop) via explicit clear() call
-    // 2. session.deleted event
-    // 3. Future /resume-continuation command
-    void sessionID
-  }
-
-  return {
-    event,
-    "chat.message": chatMessage,
-    stop,
-    isStopped,
-    clear,
-  }
-}

package/src/hooks/stop-continuation-guard/index.ts

@@ -1,2 +0,0 @@
-export { createStopContinuationGuardHook } from "./hook"
-export type { StopContinuationGuard } from "./hook"