@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/config/schema/fallback-models.ts

@@ -1,31 +0,0 @@
-import { z } from "zod"
-
-export const FallbackModelObjectSchema = z.object({
-  model: z.string(),
-  variant: z.string().optional(),
-  reasoningEffort: z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]).optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  top_p: z.number().min(0).max(1).optional(),
-  maxTokens: z.number().optional(),
-  thinking: z
-    .object({
-      type: z.enum(["enabled", "disabled"]),
-      budgetTokens: z.number().optional(),
-    })
-    .optional(),
-})
-
-export type FallbackModelObject = z.infer<typeof FallbackModelObjectSchema>
-
-export const FallbackModelStringArraySchema = z.array(z.string())
-export const FallbackModelObjectArraySchema = z.array(FallbackModelObjectSchema)
-export const FallbackModelMixedArraySchema = z.array(z.union([z.string(), FallbackModelObjectSchema]))
-
-export const FallbackModelsSchema = z.union([
-  z.string(),
-  FallbackModelStringArraySchema,
-  FallbackModelObjectArraySchema,
-  FallbackModelMixedArraySchema,
-])
-
-export type FallbackModels = z.infer<typeof FallbackModelsSchema>

package/src/config/schema/fast-apply.ts

@@ -1,14 +0,0 @@
-import { z } from "zod"
-
-export const FastApplyConfigSchema = z.object({
-  /** Enable fast-apply via Ollama (default: false) */
-  enabled: z.boolean().optional().default(false),
-  /** Ollama API URL. Configure in hiai-opencode.json. */
-  ollama_url: z.string().optional().default(""),
-  /** Model name for fast-apply. Configure in hiai-opencode.json. */
-  model: z.string().optional().default(""),
-  /** Timeout in milliseconds for Ollama request (default: 30000) */
-  timeout: z.number().int().positive().optional().default(30000),
-})
-
-export type FastApplyConfig = z.infer<typeof FastApplyConfigSchema>

package/src/config/schema/git-env-prefix.ts

@@ -1,28 +0,0 @@
-import { z } from "zod"
-
-const GIT_ENV_ASSIGNMENT_PATTERN =
-	/^(?:[A-Za-z_][A-Za-z0-9_]*=[A-Za-z0-9_-]*)(?: [A-Za-z_][A-Za-z0-9_]*=[A-Za-z0-9_-]*)*$/
-
-export const GIT_ENV_PREFIX_VALIDATION_MESSAGE =
-	'git_env_prefix must be empty or use shell-safe env assignments like "GIT_MASTER=1"'
-
-export function isValidGitEnvPrefix(value: string): boolean {
-	if (value === "") {
-		return true
-	}
-
-	return GIT_ENV_ASSIGNMENT_PATTERN.test(value)
-}
-
-export function assertValidGitEnvPrefix(value: string): string {
-	if (!isValidGitEnvPrefix(value)) {
-		throw new Error(GIT_ENV_PREFIX_VALIDATION_MESSAGE)
-	}
-
-	return value
-}
-
-export const GitEnvPrefixSchema = z
-	.string()
-	.refine(isValidGitEnvPrefix, { message: GIT_ENV_PREFIX_VALIDATION_MESSAGE })
-	.default("GIT_MASTER=1")

package/src/config/schema/git-master.ts

@@ -1,14 +0,0 @@
-import { z } from "zod"
-
-import { GitEnvPrefixSchema } from "./git-env-prefix"
-
-export const GitMasterConfigSchema = z.object({
-  /** Add "Ultraworked with Bob" footer to commit messages (default: true). Can be boolean or custom string. */
-  commit_footer: z.union([z.boolean(), z.string()]).default(true),
-  /** Add "Co-authored-by: Bob" trailer to commit messages (default: true) */
-  include_co_authored_by: z.boolean().default(true),
-  /** Environment variable prefix for all git commands (default: "GIT_MASTER=1"). Set to "" to disable. Allows custom git hooks to detect git-master skill usage. */
-  git_env_prefix: GitEnvPrefixSchema,
-})
-
-export type GitMasterConfig = z.infer<typeof GitMasterConfigSchema>

package/src/config/schema/hooks.ts

@@ -1,59 +0,0 @@
-import { z } from "zod"
-
-export const HookNameSchema = z.enum([
-  "todo-continuation-enforcer",
-  "context-window-monitor",
-  "session-recovery",
-  "session-notification",
-  "comment-checker",
-  "tool-output-truncator",
-  "question-label-truncator",
-  "directory-agents-injector",
-  "directory-readme-injector",
-  "empty-task-response-detector",
-  "think-mode",
-  "model-fallback",
-  "anthropic-context-window-limit-recovery",
-  "preemptive-compaction",
-  "rules-injector",
-  "background-notification",
-  "auto-update-checker",
-  "startup-toast",
-  "keyword-detector",
-  "agent-usage-reminder",
-  "non-interactive-env",
-  "interactive-bash-session",
-
-  "thinking-block-validator",
-  "tool-pair-validator",
-  "ralph-loop",
-  "category-skill-reminder",
-
-  "compaction-context-injector",
-  "compaction-todo-preserver",
-  "claude-code-hooks",
-  "auto-slash-command",
-  "edit-error-recovery",
-  "json-error-recovery",
-  "delegate-task-retry",
-  "strategist-md-only",
-  "sub-notepad",
-  "start-work",
-  "guard",
-  "unstable-agent-babysitter",
-  "task-resume-info",
-  "stop-continuation-guard",
-  "tasks-todowrite-disabler",
-  "runtime-fallback",
-  "write-existing-file-guard",
-  "bash-file-read-guard",
-  "anthropic-effort",
-  "hashline-read-enhancer",
-  "read-image-resizer",
-  "todo-description-override",
-  "webfetch-redirect-guard",
-  "legacy-plugin-toast",
-  "fast-apply",
-])
-
-export type HookName = z.infer<typeof HookNameSchema>

package/src/config/schema/index.ts

@@ -1,52 +0,0 @@
-export { AgentDefinitionPathSchema, AgentDefinitionsConfigSchema } from "./agent-definitions"
-export { BuiltinAgentNameSchema, BuiltinSkillNameSchema, OverridableAgentNameSchema, AgentNameSchema } from "./agent-names"
-export type { AgentName, BuiltinSkillName } from "./agent-names"
-export { AgentOverrideConfigSchema, AgentOverridesSchema } from "./agent-overrides"
-export type { AgentOverrideConfig, AgentOverrides } from "./agent-overrides"
-export { BabysittingConfigSchema } from "./babysitting"
-export type { BabysittingConfig } from "./babysitting"
-export { BackgroundTaskConfigSchema } from "./background-task"
-export type { BackgroundTaskConfig } from "./background-task"
-export { BrowserAutomationConfigSchema } from "./browser-automation"
-export type { BrowserAutomationProvider } from "./browser-automation"
-export { CategoryConfigSchema, BuiltinCategoryNameSchema, CategoriesConfigSchema } from "./categories"
-export type { CategoryConfig, CategoriesConfig, BuiltinCategoryName } from "./categories"
-export { ClaudeCodeConfigSchema } from "./claude-code"
-export { BuiltinCommandNameSchema } from "./commands"
-export type { BuiltinCommandName } from "./commands"
-export { CommentCheckerConfigSchema } from "./comment-checker"
-export type { CommentCheckerConfig } from "./comment-checker"
-export { DynamicContextPruningConfigSchema } from "./dynamic-context-pruning"
-export type { DynamicContextPruningConfig } from "./dynamic-context-pruning"
-export { ExperimentalConfigSchema } from "./experimental"
-export type { ExperimentalConfig } from "./experimental"
-export { FastApplyConfigSchema } from "./fast-apply"
-export type { FastApplyConfig } from "./fast-apply"
-export { FallbackModelObjectSchema, FallbackModelStringArraySchema, FallbackModelObjectArraySchema, FallbackModelMixedArraySchema, FallbackModelsSchema } from "./fallback-models"
-export type { FallbackModelObject } from "./fallback-models"
-export { GIT_ENV_PREFIX_VALIDATION_MESSAGE, isValidGitEnvPrefix, assertValidGitEnvPrefix, GitEnvPrefixSchema } from "./git-env-prefix"
-export { GitMasterConfigSchema } from "./git-master"
-export type { GitMasterConfig } from "./git-master"
-export { HookNameSchema } from "./hooks"
-export type { HookName } from "./hooks"
-export { ModelCapabilitiesConfigSchema } from "./model-capabilities"
-export type { ModelCapabilitiesConfig } from "./model-capabilities"
-export { NotificationConfigSchema } from "./notification"
-export type { NotificationConfig } from "./notification"
-export { HiaiOpenCodeConfigSchema } from "./oh-my-opencode-config"
-export type { HiaiOpenCodeConfig } from "./oh-my-opencode-config"
-export { RalphLoopConfigSchema } from "./ralph-loop"
-export type { RalphLoopConfig } from "./ralph-loop"
-export { RuntimeFallbackConfigSchema } from "./runtime-fallback"
-export type { RuntimeFallbackConfig } from "./runtime-fallback"
-export { BobConfigSchema } from "./bob"
-export { BobAgentConfigSchema } from "./bob-agent"
-export type { BobAgentConfig } from "./bob-agent"
-export { SkillsConfigSchema } from "./skills"
-export type { SkillsConfig, SkillDefinition } from "./skills"
-export { SkillDiscoveryConfigSchema } from "./skill-discovery"
-export type { SkillDiscoveryConfig } from "./skill-discovery"
-export { StartWorkConfigSchema } from "./start-work"
-export type { StartWorkConfig } from "./start-work"
-export { TmuxConfigSchema, TmuxLayoutSchema, TmuxIsolationSchema } from "./tmux"
-export type { TmuxConfig, TmuxLayout, TmuxIsolation } from "./tmux"

package/src/config/schema/internal/permission.ts

@@ -1,20 +0,0 @@
-import { z } from "zod"
-
-export const PermissionValueSchema = z.enum(["ask", "allow", "deny"])
-export type PermissionValue = z.infer<typeof PermissionValueSchema>
-
-const BashPermissionSchema = z.union([
-  PermissionValueSchema,
-  z.record(z.string(), PermissionValueSchema),
-])
-
-export const AgentPermissionSchema = z.object({
-  edit: PermissionValueSchema.optional(),
-  bash: BashPermissionSchema.optional(),
-  webfetch: PermissionValueSchema.optional(),
-  task: PermissionValueSchema.optional(),
-  doom_loop: PermissionValueSchema.optional(),
-  external_directory: PermissionValueSchema.optional(),
-})
-
-export type AgentPermission = z.infer<typeof AgentPermissionSchema>

package/src/config/schema/model-capabilities.ts

@@ -1,10 +0,0 @@
-import { z } from "zod"
-
-export const ModelCapabilitiesConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  auto_refresh_on_start: z.boolean().optional(),
-  refresh_timeout_ms: z.number().int().positive().optional(),
-  source_url: z.string().url().optional(),
-})
-
-export type ModelCapabilitiesConfig = z.infer<typeof ModelCapabilitiesConfigSchema>

package/src/config/schema/notification.ts

@@ -1,8 +0,0 @@
-import { z } from "zod"
-
-export const NotificationConfigSchema = z.object({
-  /** Force enable session-notification even if external notification plugins are detected (default: false) */
-  force_enable: z.boolean().optional(),
-})
-
-export type NotificationConfig = z.infer<typeof NotificationConfigSchema>

package/src/config/schema/oh-my-opencode-config.ts

@@ -1,88 +0,0 @@
-import { z } from "zod"
-import { AnyMcpNameSchema } from "../../mcp/types"
-import { BuiltinSkillNameSchema } from "./agent-names"
-import { AgentDefinitionsConfigSchema } from "./agent-definitions"
-import { AgentOverridesSchema } from "./agent-overrides"
-import { BabysittingConfigSchema } from "./babysitting"
-import { BackgroundTaskConfigSchema } from "./background-task"
-import { BrowserAutomationConfigSchema } from "./browser-automation"
-import { CategoriesConfigSchema } from "./categories"
-import { ClaudeCodeConfigSchema } from "./claude-code"
-import { CommentCheckerConfigSchema } from "./comment-checker"
-import { BuiltinCommandNameSchema } from "./commands"
-import { ExperimentalConfigSchema } from "./experimental"
-import { GitMasterConfigSchema } from "./git-master"
-import { NotificationConfigSchema } from "./notification"
-import { ModelCapabilitiesConfigSchema } from "./model-capabilities"
-import { RalphLoopConfigSchema } from "./ralph-loop"
-import { RuntimeFallbackConfigSchema } from "./runtime-fallback"
-import { SkillsConfigSchema } from "./skills"
-import { SkillDiscoveryConfigSchema } from "./skill-discovery"
-import { BobConfigSchema } from "./bob"
-import { BobAgentConfigSchema } from "./bob-agent"
-import { TmuxConfigSchema } from "./tmux"
-import { StartWorkConfigSchema } from "./start-work"
-import { FastApplyConfigSchema } from "./fast-apply"
-
-const AuthConfigSchema = z.object({
-  stitch: z.string().optional(),
-  firecrawl: z.string().optional(),
-  context7: z.string().optional(),
-}).optional()
-
-export const HiaiOpenCodeConfigSchema = z.object({
-  $schema: z.string().optional(),
-  /** Enable new task system (default: false) */
-  new_task_system_enabled: z.boolean().optional(),
-  /** Default agent name for `hiai-opencode run` (env: OPENCODE_DEFAULT_AGENT) */
-  default_run_agent: z.string().optional(),
-  /** Paths to external agent definition files (.md or .json) */
-  agent_definitions: AgentDefinitionsConfigSchema,
-  disabled_mcps: z.array(AnyMcpNameSchema).optional(),
-  disabled_agents: z.array(z.string()).optional(),
-  disabled_skills: z.array(BuiltinSkillNameSchema).optional(),
-  disabled_hooks: z.array(z.string()).optional(),
-  disabled_commands: z.array(BuiltinCommandNameSchema).optional(),
-  /** Disable specific tools by name (e.g., ["todowrite", "todoread"]) */
-  disabled_tools: z.array(z.string()).optional(),
-  mcp_env_allowlist: z.array(z.string()).optional(),
-  /** Enable hashline_edit tool/hook integrations (default: false) */
-  hashline_edit: z.boolean().optional(),
-  /** Enable model fallback on API errors (default: false). Set to true to enable automatic model switching when model errors occur. */
-  model_fallback: z.boolean().optional(),
-  agents: AgentOverridesSchema.optional(),
-  categories: CategoriesConfigSchema.optional(),
-  claude_code: ClaudeCodeConfigSchema.optional(),
-  bob_agent: BobAgentConfigSchema.optional(),
-  comment_checker: CommentCheckerConfigSchema.optional(),
-  experimental: ExperimentalConfigSchema.optional(),
-  auto_update: z.boolean().optional(),
-  skills: SkillsConfigSchema.optional(),
-  skill_discovery: SkillDiscoveryConfigSchema.optional(),
-  ralph_loop: RalphLoopConfigSchema.optional(),
-  /**
-   * Enable runtime fallback (default: false)
-   * Set to false to disable, or use object for advanced config:
-   * { "enabled": true, "retry_on_errors": [400, 429], "timeout_seconds": 30 }
-   */
-  runtime_fallback: z.union([z.boolean(), RuntimeFallbackConfigSchema]).optional(),
-  background_task: BackgroundTaskConfigSchema.optional(),
-  notification: NotificationConfigSchema.optional(),
-  model_capabilities: ModelCapabilitiesConfigSchema.optional(),
-  babysitting: BabysittingConfigSchema.optional(),
-  auth: AuthConfigSchema,
-  git_master: GitMasterConfigSchema.default({
-    commit_footer: true,
-    include_co_authored_by: true,
-    git_env_prefix: "GIT_MASTER=1",
-  }),
-  browser_automation_engine: BrowserAutomationConfigSchema.optional(),
-  tmux: TmuxConfigSchema.optional(),
-  "bob": BobConfigSchema.optional(),
-  start_work: StartWorkConfigSchema.optional(),
-  fast_apply: FastApplyConfigSchema.optional(),
-  /** Migration history to prevent re-applying migrations (e.g., model version upgrades) */
-  _migrations: z.array(z.string()).optional(),
-})
-
-export type HiaiOpenCodeConfig = z.infer<typeof HiaiOpenCodeConfigSchema>

package/src/config/schema/openclaw.ts

@@ -1,50 +0,0 @@
-import { z } from "zod"
-
-export const OpenClawGatewaySchema = z.object({
-  type: z.enum(["http", "command"]).default("http"),
-  // HTTP specific
-  url: z.string().optional(),
-  method: z.string().default("POST"),
-  headers: z.record(z.string(), z.string()).optional(),
-  // Command specific
-  command: z.string().optional(),
-  // Shared
-  timeout: z.number().optional(),
-})
-
-export const OpenClawHookSchema = z.object({
-  enabled: z.boolean().default(true),
-  gateway: z.string(),
-  instruction: z.string(),
-})
-
-export const OpenClawReplyListenerConfigSchema = z.object({
-  discordBotToken: z.string().optional(),
-  discordChannelId: z.string().optional(),
-  discordMention: z.string().optional(), // For allowed_mentions
-  authorizedDiscordUserIds: z.array(z.string()).default([]),
-
-  telegramBotToken: z.string().optional(),
-  telegramChatId: z.string().optional(),
-
-  pollIntervalMs: z.number().default(3000),
-  rateLimitPerMinute: z.number().default(10),
-  maxMessageLength: z.number().default(500),
-  includePrefix: z.boolean().default(true),
-})
-
-export const OpenClawConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-
-  // Outbound Configuration
-  gateways: z.record(z.string(), OpenClawGatewaySchema).default({}),
-  hooks: z.record(z.string(), OpenClawHookSchema).default({}),
-
-  // Inbound Configuration (Reply Listener)
-  replyListener: OpenClawReplyListenerConfigSchema.optional(),
-})
-
-export type OpenClawConfig = z.infer<typeof OpenClawConfigSchema>
-export type OpenClawGateway = z.infer<typeof OpenClawGatewaySchema>
-export type OpenClawHook = z.infer<typeof OpenClawHookSchema>
-export type OpenClawReplyListenerConfig = z.infer<typeof OpenClawReplyListenerConfigSchema>

package/src/config/schema/ralph-loop.ts

@@ -1,11 +0,0 @@
-import { z } from "zod"
-
-export const RalphLoopConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  default_max_iterations: z.number().min(1).max(1000).default(100),
-  /** Custom state file directory relative to project root (default: .opencode/) */
-  state_dir: z.string().optional(),
-  default_strategy: z.enum(["reset", "continue"]).default("continue"),
-})
-
-export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>

package/src/config/schema/runtime-fallback.ts

@@ -1,18 +0,0 @@
-import { z } from "zod"
-
-export const RuntimeFallbackConfigSchema = z.object({
-  /** Enable runtime fallback (default: false) */
-  enabled: z.boolean().optional(),
-  /** HTTP status codes that trigger fallback (default: [400, 429, 503, 529]) */
-  retry_on_errors: z.array(z.number()).optional(),
-  /** Maximum fallback attempts per session (default: 3) */
-  max_fallback_attempts: z.number().min(1).max(20).optional(),
-  /** Cooldown in seconds before retrying a failed model (default: 60) */
-  cooldown_seconds: z.number().min(0).optional(),
-  /** Session-level timeout in seconds to advance fallback when provider hangs (default: 30). Set to 0 to disable auto-retry signal detection (only error-based fallback remains active). */
-  timeout_seconds: z.number().min(0).optional(),
-  /** Show toast notification when switching to fallback model (default: true) */
-  notify_on_fallback: z.boolean().optional(),
-})
-
-export type RuntimeFallbackConfig = z.infer<typeof RuntimeFallbackConfigSchema>

package/src/config/schema/skill-discovery.ts

@@ -1,25 +0,0 @@
-import { z } from "zod"
-
-export const SkillDiscoveryConfigSchema = z.object({
-  /**
-   * Explicit skills.sources entries from hiai-opencode config.
-   * Safe by default because the user intentionally configured them.
-   */
-  config_sources: z.boolean().default(true),
-  /**
-   * Project-local OpenCode skills: .opencode/skills and .opencode/skill.
-   * Kept on by default because they are part of the current project contract.
-   */
-  project_opencode: z.boolean().default(true),
-  /**
-   * Global OpenCode skills from the user's OpenCode config directory.
-   * Off by default to keep clean installs deterministic.
-   */
-  global_opencode: z.boolean().default(false),
-  project_claude: z.boolean().default(false),
-  global_claude: z.boolean().default(false),
-  project_agents: z.boolean().default(false),
-  global_agents: z.boolean().default(false),
-})
-
-export type SkillDiscoveryConfig = z.infer<typeof SkillDiscoveryConfigSchema>

package/src/config/schema/skills.ts

@@ -1,39 +0,0 @@
-import { z } from "zod"
-
-export const SkillSourceSchema = z.union([
-  z.string(),
-  z.object({
-    path: z.string(),
-    recursive: z.boolean().optional(),
-    glob: z.string().optional(),
-  }),
-])
-
-export const SkillDefinitionSchema = z.object({
-  description: z.string().optional(),
-  template: z.string().optional(),
-  from: z.string().optional(),
-  model: z.string().optional(),
-  agent: z.string().optional(),
-  subtask: z.boolean().optional(),
-  "argument-hint": z.string().optional(),
-  license: z.string().optional(),
-  compatibility: z.string().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  "allowed-tools": z.array(z.string()).optional(),
-  disable: z.boolean().optional(),
-})
-
-export const SkillEntrySchema = z.union([z.boolean(), SkillDefinitionSchema])
-
-export const SkillsConfigSchema = z.union([
-  z.array(z.string()),
-  z.object({
-    sources: z.array(SkillSourceSchema).optional(),
-    enable: z.array(z.string()).optional(),
-    disable: z.array(z.string()).optional(),
-  }).catchall(SkillEntrySchema),
-])
-
-export type SkillsConfig = z.infer<typeof SkillsConfigSchema>
-export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>

package/src/config/schema/start-work.ts

@@ -1,7 +0,0 @@
-import { z } from "zod"
-
-export const StartWorkConfigSchema = z.object({
-  auto_commit: z.boolean().default(true),
-})
-
-export type StartWorkConfig = z.infer<typeof StartWorkConfigSchema>

package/src/config/schema/tmux.ts

@@ -1,28 +0,0 @@
-import { z } from "zod"
-
-export const TmuxLayoutSchema = z.enum([
-  "main-horizontal", // main pane top, agent panes bottom stack
-  "main-vertical", // main pane left, agent panes right stack (default)
-  "tiled", // all panes same size grid
-  "even-horizontal", // all panes horizontal row
-  "even-vertical", // all panes vertical stack
-])
-
-export const TmuxIsolationSchema = z.enum([
-  "inline",   // panes split in user's current window (legacy behavior)
-  "window",   // panes created in a separate tmux window (same session)
-  "session",  // panes created in a detached tmux session (full isolation)
-])
-
-export const TmuxConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  layout: TmuxLayoutSchema.default("main-vertical"),
-  main_pane_size: z.number().min(20).max(80).default(60),
-  main_pane_min_width: z.number().min(40).default(120),
-  agent_pane_min_width: z.number().min(20).default(40),
-  isolation: TmuxIsolationSchema.default("inline"),
-})
-
-export type TmuxConfig = z.infer<typeof TmuxConfigSchema>
-export type TmuxLayout = z.infer<typeof TmuxLayoutSchema>
-export type TmuxIsolation = z.infer<typeof TmuxIsolationSchema>