@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/features/boulder-state/constants.ts

@@ -1,13 +0,0 @@
-/**
- * Boulder State Constants
- */
-
-export const BOULDER_DIR = ".bob"
-export const BOULDER_FILE = "boulder.json"
-export const BOULDER_STATE_PATH = `${BOULDER_DIR}/${BOULDER_FILE}`
-
-export const NOTEPAD_DIR = "notepads"
-export const NOTEPAD_BASE_PATH = `${BOULDER_DIR}/${NOTEPAD_DIR}`
-
-/** Strategist plan directory pattern */
-export const PROMETHEUS_PLANS_DIR = ".bob/plans"

package/src/features/boulder-state/index.ts

@@ -1,4 +0,0 @@
-export * from "./types"
-export * from "./constants"
-export * from "./storage"
-export * from "./top-level-task"

package/src/features/boulder-state/storage.ts

@@ -1,336 +0,0 @@
-/**
- * Boulder State Storage
- *
- * Handles reading/writing boulder.json for active plan tracking.
- */
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs"
-import { dirname, join, basename } from "node:path"
-import type { BoulderState, PlanProgress, TaskSessionState } from "./types"
-import { BOULDER_DIR, BOULDER_FILE, PROMETHEUS_PLANS_DIR } from "./constants"
-
-const RESERVED_KEYS = new Set(["__proto__", "prototype", "constructor"])
-
-export function getBoulderFilePath(directory: string): string {
-  return join(directory, BOULDER_DIR, BOULDER_FILE)
-}
-
-export function readBoulderState(directory: string): BoulderState | null {
-  const filePath = getBoulderFilePath(directory)
-
-  if (!existsSync(filePath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(filePath, "utf-8")
-    const parsed = JSON.parse(content)
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null
-    }
-    if (!Array.isArray(parsed.session_ids)) {
-      parsed.session_ids = []
-    }
-    if (!parsed.session_origins || typeof parsed.session_origins !== "object" || Array.isArray(parsed.session_origins)) {
-      parsed.session_origins = {}
-    }
-    if (parsed.session_ids.length === 1) {
-      const soleSessionId = parsed.session_ids[0]
-      if (
-        typeof soleSessionId === "string"
-        && parsed.session_origins[soleSessionId] !== "appended"
-        && parsed.session_origins[soleSessionId] !== "direct"
-      ) {
-        parsed.session_origins[soleSessionId] = "direct"
-      }
-    }
-    if (!parsed.task_sessions || typeof parsed.task_sessions !== "object" || Array.isArray(parsed.task_sessions)) {
-      parsed.task_sessions = {}
-    }
-    return parsed as BoulderState
-  } catch {
-    return null
-  }
-}
-
-export function writeBoulderState(directory: string, state: BoulderState): boolean {
-  const filePath = getBoulderFilePath(directory)
-
-  try {
-    const dir = dirname(filePath)
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true })
-    }
-
-    writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8")
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function appendSessionId(
-  directory: string,
-  sessionId: string,
-  origin: "direct" | "appended" = "direct",
-): BoulderState | null {
-  const state = readBoulderState(directory)
-  if (!state) return null
-
-  if (!state.session_origins || typeof state.session_origins !== "object" || Array.isArray(state.session_origins)) {
-    state.session_origins = {}
-  }
-
-  if (!state.session_ids?.includes(sessionId)) {
-    if (!Array.isArray(state.session_ids)) {
-      state.session_ids = []
-    }
-    const originalSessionIds = [...state.session_ids]
-    const originalSessionOrigins = { ...state.session_origins }
-    state.session_ids.push(sessionId)
-    state.session_origins[sessionId] = origin
-    if (writeBoulderState(directory, state)) {
-      return state
-    }
-    state.session_ids = originalSessionIds
-    state.session_origins = originalSessionOrigins
-    return null
-  }
-
-  if (!state.session_origins[sessionId]) {
-    state.session_origins[sessionId] = origin
-    if (!writeBoulderState(directory, state)) {
-      return null
-    }
-  }
-
-  return state
-}
-
-export function clearBoulderState(directory: string): boolean {
-  const filePath = getBoulderFilePath(directory)
-
-  try {
-    if (existsSync(filePath)) {
-      const { unlinkSync } = require("node:fs")
-      unlinkSync(filePath)
-    }
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function getTaskSessionState(directory: string, taskKey: string): TaskSessionState | null {
-  const state = readBoulderState(directory)
-  if (!state?.task_sessions) {
-    return null
-  }
-
-  return state.task_sessions[taskKey] ?? null
-}
-
-export function upsertTaskSessionState(
-  directory: string,
-  input: {
-    taskKey: string
-    taskLabel: string
-    taskTitle: string
-    sessionId: string
-    agent?: string
-    category?: string
-  },
-): BoulderState | null {
-  const state = readBoulderState(directory)
-  if (!state) {
-    return null
-  }
-
-  if (RESERVED_KEYS.has(input.taskKey)) {
-    return null
-  }
-
-  const taskSessions = state.task_sessions ?? {}
-  taskSessions[input.taskKey] = {
-    task_key: input.taskKey,
-    task_label: input.taskLabel,
-    task_title: input.taskTitle,
-    session_id: input.sessionId,
-    ...(input.agent !== undefined ? { agent: input.agent } : {}),
-    ...(input.category !== undefined ? { category: input.category } : {}),
-    updated_at: new Date().toISOString(),
-  }
-
-  state.task_sessions = taskSessions
-  if (writeBoulderState(directory, state)) {
-    return state
-  }
-
-  return null
-}
-
-/**
- * Find Strategist plan files for this project.
- * Strategist stores plans at: {project}/.bob/plans/{name}.md
- */
-export function findStrategistPlans(directory: string): string[] {
-  const plansDir = join(directory, PROMETHEUS_PLANS_DIR)
-
-  if (!existsSync(plansDir)) {
-    return []
-  }
-
-  try {
-    const files = readdirSync(plansDir)
-    return files
-      .filter((f) => f.endsWith(".md"))
-      .map((f) => join(plansDir, f))
-      .sort((a, b) => {
-        // Sort by modification time, newest first
-        const aStat = require("node:fs").statSync(a)
-        const bStat = require("node:fs").statSync(b)
-        return bStat.mtimeMs - aStat.mtimeMs
-      })
-  } catch {
-    return []
-  }
-}
-
-const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i
-const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i
-const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/
-const UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/
-const CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/
-const TODO_TASK_PATTERN = /^\d+\.\s+/
-const FINAL_WAVE_TASK_PATTERN = /^F\d+\.\s+/i
-
-type ProgressSection = "todo" | "final-wave" | "other"
-
-/**
- * Parse a plan file and count checkbox progress.
- *
- * Only top-level (zero-indent) checkboxes under `## TODOs` and
- * `## Final Verification Wave` sections are counted. The checkbox
- * body must carry a valid task label (`N.` for TODOs, `FN.` for
- * Final Verification Wave). Nested acceptance-criteria checkboxes
- * and checkboxes in other sections are intentionally ignored so
- * that progress tracking stays aligned with `readCurrentTopLevelTask`.
- */
-export function getPlanProgress(planPath: string): PlanProgress {
-  if (!existsSync(planPath)) {
-    return { total: 0, completed: 0, isComplete: true }
-  }
-
-  try {
-    const content = readFileSync(planPath, "utf-8")
-    const lines = content.split(/\r?\n/)
-
-    // Check if the plan has structured sections (## TODOs / ## Final Verification Wave)
-    const hasStructuredSections = lines.some(
-      (line) => TODO_HEADING_PATTERN.test(line) || FINAL_VERIFICATION_HEADING_PATTERN.test(line),
-    )
-
-    if (hasStructuredSections) {
-      // Structured plan: only count top-level checkboxes with numbered labels
-      // under ## TODOs and ## Final Verification Wave sections
-      return getStructuredPlanProgress(lines)
-    }
-
-    // Simple plan: count all top-level checkboxes anywhere
-    return getSimplePlanProgress(content)
-  } catch {
-    return { total: 0, completed: 0, isComplete: true }
-  }
-}
-
-function getStructuredPlanProgress(lines: string[]): PlanProgress {
-  let section: ProgressSection = "other"
-  let total = 0
-  let completed = 0
-
-  for (const line of lines) {
-    if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
-      section = TODO_HEADING_PATTERN.test(line)
-        ? "todo"
-        : FINAL_VERIFICATION_HEADING_PATTERN.test(line)
-          ? "final-wave"
-          : "other"
-      continue
-    }
-
-    if (section !== "todo" && section !== "final-wave") {
-      continue
-    }
-
-    const checkedMatch = line.match(CHECKED_CHECKBOX_PATTERN)
-    const uncheckedMatch = checkedMatch ? null : line.match(UNCHECKED_CHECKBOX_PATTERN)
-    const match = checkedMatch ?? uncheckedMatch
-    if (!match) {
-      continue
-    }
-
-    if (match[1].length > 0) {
-      continue
-    }
-
-    const taskBody = match[2].trim()
-    const labelPattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN
-    if (!labelPattern.test(taskBody)) {
-      continue
-    }
-
-    total++
-    if (checkedMatch) {
-      completed++
-    }
-  }
-
-  return {
-    total,
-    completed,
-    isComplete: total > 0 && completed === total,
-  }
-}
-
-function getSimplePlanProgress(content: string): PlanProgress {
-  const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || []
-  const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || []
-
-  const total = uncheckedMatches.length + checkedMatches.length
-  const completed = checkedMatches.length
-
-  return {
-    total,
-    completed,
-    isComplete: total > 0 && completed === total,
-  }
-}
-
-/**
- * Extract plan name from file path.
- */
-export function getPlanName(planPath: string): string {
-  return basename(planPath, ".md")
-}
-
-/**
- * Create a new boulder state for a plan.
- */
-export function createBoulderState(
-  planPath: string,
-  sessionId: string,
-  agent?: string,
-  worktreePath?: string,
-): BoulderState {
-  return {
-    active_plan: planPath,
-    started_at: new Date().toISOString(),
-    session_ids: [sessionId],
-    session_origins: {
-      [sessionId]: "direct",
-    },
-    plan_name: getPlanName(planPath),
-    ...(agent !== undefined ? { agent } : {}),
-    ...(worktreePath !== undefined ? { worktree_path: worktreePath } : {}),
-  }
-}

package/src/features/boulder-state/top-level-task.ts

@@ -1,78 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-
-import type { TopLevelTaskRef } from "./types"
-
-const TODO_HEADING_PATTERN = /^##\s+TODOs\b/i
-const FINAL_VERIFICATION_HEADING_PATTERN = /^##\s+Final Verification Wave\b/i
-const SECOND_LEVEL_HEADING_PATTERN = /^##\s+/
-const UNCHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[\s*\]\s*(.+)$/
-const CHECKED_CHECKBOX_PATTERN = /^(\s*)[-*]\s*\[[xX]\]\s*(.+)$/
-const TODO_TASK_PATTERN = /^(\d+)\.\s+(.+)$/
-const FINAL_WAVE_TASK_PATTERN = /^(F\d+)\.\s+(.+)$/i
-
-type PlanSection = "todo" | "final-wave" | "other"
-
-function buildTaskRef(
-  section: "todo" | "final-wave",
-  taskLabel: string,
-): TopLevelTaskRef | null {
-  const pattern = section === "todo" ? TODO_TASK_PATTERN : FINAL_WAVE_TASK_PATTERN
-  const match = taskLabel.match(pattern)
-  if (!match) {
-    return null
-  }
-
-  const rawLabel = match[1]
-  const title = match[2].trim()
-
-  return {
-    key: `${section}:${rawLabel.toLowerCase()}`,
-    section,
-    label: rawLabel,
-    title,
-  }
-}
-
-export function readCurrentTopLevelTask(planPath: string): TopLevelTaskRef | null {
-  if (!existsSync(planPath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(planPath, "utf-8")
-    const lines = content.split(/\r?\n/)
-    let section: PlanSection = "other"
-
-    for (const line of lines) {
-      if (SECOND_LEVEL_HEADING_PATTERN.test(line)) {
-        section = TODO_HEADING_PATTERN.test(line)
-          ? "todo"
-          : FINAL_VERIFICATION_HEADING_PATTERN.test(line)
-            ? "final-wave"
-            : "other"
-      }
-
-      const uncheckedTaskMatch = line.match(UNCHECKED_CHECKBOX_PATTERN)
-      if (!uncheckedTaskMatch) {
-        continue
-      }
-
-      if (uncheckedTaskMatch[1].length > 0) {
-        continue
-      }
-
-      if (section !== "todo" && section !== "final-wave") {
-        continue
-      }
-
-      const taskRef = buildTaskRef(section, uncheckedTaskMatch[2].trim())
-      if (taskRef) {
-        return taskRef
-      }
-    }
-
-    return null
-  } catch {
-    return null
-  }
-}

package/src/features/boulder-state/types.ts

@@ -1,61 +0,0 @@
-/**
- * Boulder State Types
- *
- * Manages the active work plan state for Bob orchestrator.
- * Named after Bob's boulder - the eternal task that must be rolled.
- */
-
-export interface BoulderState {
-  /** Absolute path to the active plan file */
-  active_plan: string
-  /** ISO timestamp when work started */
-  started_at: string
-  /** Session IDs that have worked on this plan */
-  session_ids: string[]
-  session_origins?: Record<string, "direct" | "appended">
-  /** Plan name derived from filename */
-  plan_name: string
-  /** Agent type to use when resuming (e.g., 'guard') */
-  agent?: string
-  /** Absolute path to the git worktree root where work happens */
-  worktree_path?: string
-  /** Preferred reusable subagent sessions keyed by current top-level plan task */
-  task_sessions?: Record<string, TaskSessionState>
-}
-
-export interface PlanProgress {
-  /** Total number of checkboxes */
-  total: number
-  /** Number of completed checkboxes */
-  completed: number
-  /** Whether all tasks are done */
-  isComplete: boolean
-}
-
-export interface TaskSessionState {
-  /** Stable identifier for the current top-level plan task (e.g. todo:1 / final-wave:F1) */
-  task_key: string
-  /** Original task label from the plan file */
-  task_label: string
-  /** Full task title from the plan file */
-  task_title: string
-  /** Preferred reusable subagent session */
-  session_id: string
-  /** Agent associated with the task session, when known */
-  agent?: string
-  /** Category associated with the task session, when known */
-  category?: string
-  /** Last update timestamp */
-  updated_at: string
-}
-
-export interface TopLevelTaskRef {
-  /** Stable identifier for the current top-level plan task */
-  key: string
-  /** Task section in the Strategist plan */
-  section: "todo" | "final-wave"
-  /** Original label token (e.g. 1 / F1) */
-  label: string
-  /** Full task title extracted from the checkbox line */
-  title: string
-}

package/src/features/builtin-commands/commands.ts

@@ -1,157 +0,0 @@
-import type { CommandDefinition } from "../claude-code-command-loader"
-import { isAgentRegistered } from "../claude-code-session-state"
-import type { BuiltinCommandName, BuiltinCommands } from "./types"
-import { INIT_DEEP_TEMPLATE } from "./templates/init-deep"
-import { RALPH_LOOP_TEMPLATE, ULW_LOOP_TEMPLATE, CANCEL_RALPH_TEMPLATE } from "./templates/ralph-loop"
-import { STOP_CONTINUATION_TEMPLATE } from "./templates/stop-continuation"
-import { REFACTOR_TEMPLATE } from "./templates/refactor"
-import { START_WORK_TEMPLATE } from "./templates/start-work"
-import { HANDOFF_TEMPLATE } from "./templates/handoff"
-import { REMOVE_AI_SLOPS_TEMPLATE } from "./templates/remove-ai-slops"
-import { MCP_STATUS_TEMPLATE } from "./templates/mcp-status"
-import { DOCTOR_TEMPLATE } from "./templates/doctor"
-
-interface LoadBuiltinCommandsOptions {
-  useRegisteredAgents?: boolean
-}
-
-function resolveStartWorkAgent(options?: LoadBuiltinCommandsOptions): "guard" | "bob" {
-  if (options?.useRegisteredAgents) {
-    return isAgentRegistered("guard") ? "guard" : "bob"
-  }
-
-  return "guard"
-}
-
-function createBuiltinCommandDefinitions(
-  options?: LoadBuiltinCommandsOptions,
-): Record<BuiltinCommandName, Omit<CommandDefinition, "name">> {
-  return {
-    "init-deep": {
-      description: "(builtin) Initialize hierarchical AGENTS.md knowledge base",
-      template: `<command-instruction>
-${INIT_DEEP_TEMPLATE}
-</command-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`,
-      argumentHint: "[--create-new] [--max-depth=N]",
-    },
-     "ralph-loop": {
-       description: "(builtin) Start self-referential development loop until completion",
-       template: `<command-instruction>
-${RALPH_LOOP_TEMPLATE}
-</command-instruction>
-
-<user-task>
-$ARGUMENTS
-</user-task>`,
-       argumentHint: '"task description" [--completion-promise=TEXT] [--max-iterations=N] [--strategy=reset|continue]',
-     },
-     "ulw-loop": {
-        description: "(builtin) Start ultrawork loop - continues until completion with ultrawork mode",
-        template: `<command-instruction>
-${ULW_LOOP_TEMPLATE}
-</command-instruction>
-
-<user-task>
-$ARGUMENTS
-</user-task>`,
-        argumentHint: '"task description" [--completion-promise=TEXT] [--strategy=reset|continue]',
-      },
-    "cancel-ralph": {
-      description: "(builtin) Cancel active Ralph Loop",
-      template: `<command-instruction>
-${CANCEL_RALPH_TEMPLATE}
-</command-instruction>`,
-    },
-    refactor: {
-      description:
-        "(builtin) Intelligent refactoring command with LSP, AST-grep, architecture analysis, codemap, and TDD verification.",
-      template: `<command-instruction>
-${REFACTOR_TEMPLATE}
-</command-instruction>`,
-      argumentHint: "<refactoring-target> [--scope=<file|module|project>] [--strategy=<safe|aggressive>]",
-    },
-    "start-work": {
-      description: "(builtin) Start Bob work session from Strategist plan",
-      agent: resolveStartWorkAgent(options),
-      template: `<command-instruction>
-${START_WORK_TEMPLATE}
-</command-instruction>
-
-<session-context>
-Session ID: $SESSION_ID
-Timestamp: $TIMESTAMP
-</session-context>
-
-<user-request>
-$ARGUMENTS
-</user-request>`,
-      argumentHint: "[plan-name]",
-    },
-    "stop-continuation": {
-      description: "(builtin) Stop all continuation mechanisms (ralph loop, todo continuation, boulder) for this session",
-      template: `<command-instruction>
-${STOP_CONTINUATION_TEMPLATE}
-</command-instruction>`,
-    },
-    "remove-ai-slops": {
-      description: "(builtin) Remove AI-generated code smells from branch changes and critically review the results",
-      template: `<command-instruction>
-${REMOVE_AI_SLOPS_TEMPLATE}
-</command-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`,
-    },
-    handoff: {
-      description: "(builtin) Create a detailed context summary for continuing work in a new session",
-      template: `<command-instruction>
-${HANDOFF_TEMPLATE}
-</command-instruction>
-
-<session-context>
-Session ID: $SESSION_ID
-Timestamp: $TIMESTAMP
-</session-context>
-
-<user-request>
-$ARGUMENTS
-</user-request>`,
-      argumentHint: "[goal]",
-    },
-    "mcp-status": {
-      description: "(builtin) Show hiai-opencode MCP server status, missing keys, and local runtime availability",
-      template: `<command-instruction>
-${MCP_STATUS_TEMPLATE}
-</command-instruction>`,
-    },
-    doctor: {
-      description: "(builtin) Run hiai-opencode install/runtime diagnostics and explain setup issues",
-      template: `<command-instruction>
-${DOCTOR_TEMPLATE}
-</command-instruction>`,
-    },
-  }
-}
-
-export function loadBuiltinCommands(
-  disabledCommands?: BuiltinCommandName[],
-  options?: LoadBuiltinCommandsOptions,
-): BuiltinCommands {
-  const builtinCommandDefinitions = createBuiltinCommandDefinitions(options)
-  const disabled = new Set(disabledCommands ?? [])
-  const commands: BuiltinCommands = {}
-
-  for (const [name, definition] of Object.entries(builtinCommandDefinitions)) {
-    if (!disabled.has(name as BuiltinCommandName)) {
-      const { argumentHint: _argumentHint, ...openCodeCompatible } = definition
-      commands[name] = { ...openCodeCompatible, name } as CommandDefinition
-    }
-  }
-
-  return commands
-}

package/src/features/builtin-commands/index.ts

@@ -1,2 +0,0 @@
-export * from "./types"
-export * from "./commands"

package/src/features/builtin-commands/templates/doctor.ts

@@ -1,43 +0,0 @@
-export const DOCTOR_TEMPLATE = `# Hiai OpenCode Doctor Command
-
-## Purpose
-
-Use /doctor to run the hiai-opencode install/runtime diagnostic and report actionable setup issues.
-
-## Execute
-
-Run:
-
-\`\`\`bash
-hiai-opencode doctor
-\`\`\`
-
-If the binary is not on PATH, try the package-local fallback:
-
-\`\`\`bash
-node ./node_modules/@hiai-gg/hiai-opencode/assets/cli/hiai-opencode.mjs doctor
-\`\`\`
-
-## Report
-
-Summarize:
-
-- config path
-- enabled and disabled MCP servers
-- missing env vars by name only
-- static \`.mcp.json\` freshness and whether it is managed by hiai-opencode
-- OpenCode Connect visibility for configured model providers
-- OpenCode plugin registration sanity (including \`plugin: ["list"]\` misconfiguration warning)
-- skill materialization status from skill registry
-- agent count and naming summary
-- LSP runtime availability
-- MemPalace python source and selected interpreter (env/config/auto)
-- MCP tool probes (real connect + tools/list) for stdio and basic endpoint probes for remote MCP
-
-Rules:
-
-- Do not print API key values.
-- Do not ask for model provider env vars such as OPENROUTER_API_KEY or OPENAI_API_KEY; normal model auth belongs to OpenCode Connect.
-- If \`opencode mcp list\` is empty but doctor/mcp-status sees servers, explain the runtime-vs-static config distinction and run \`hiai-opencode export-mcp .mcp.json\` if the user wants static visibility.
-- Do not run package installs unless the user explicitly asks.
-`