@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/features/claude-code-plugin-loader/types.ts

@@ -1,255 +0,0 @@
-/**
- * Claude Code Plugin Types
- * 
- * Type definitions for Claude Code plugin system compatibility.
- * Based on https://code.claude.com/docs/en/plugins-reference
- */
-
-export type PluginScope = "user" | "project" | "local" | "managed"
-
-/**
- * Plugin installation entry in installed_plugins.json
- */
-export interface PluginInstallation {
-  scope: PluginScope
-  installPath: string
-  version: string
-  installedAt: string
-  lastUpdated: string
-  gitCommitSha?: string
-  isLocal?: boolean
-  /**
-   * Claude Code records this on project/local-scoped installations.
-   * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
-   * Used to filter project/local plugins that do not belong to the current cwd.
-   */
-  projectPath?: string
-}
-
-/**
- * Installed plugins database v1 (legacy)
- * plugins stored as direct objects
- */
-export interface InstalledPluginsDatabaseV1 {
-  version: 1
-  plugins: Record<string, PluginInstallation>
-}
-
-/**
- * Installed plugins database v2
- * plugins stored as arrays keyed by plugin identifier
- */
-export interface InstalledPluginsDatabaseV2 {
-  version: 2
-  plugins: Record<string, PluginInstallation[]>
-}
-
-/**
- * Installed plugins database v3 entry (current Claude Code format)
- * A flat array of plugin entries, each containing name and marketplace fields
- * used to construct the plugin key as "name@marketplace".
- */
-export interface InstalledPluginEntryV3 {
-  name: string
-  marketplace: string
-  scope: PluginScope
-  version: string
-  installPath: string
-  lastUpdated: string
-  gitCommitSha?: string
-  /**
-   * Claude Code records this on project/local-scoped installations.
-   * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
-   */
-  projectPath?: string
-}
-
-/**
- * Installed plugins database structure
- * Located at ~/.claude/plugins/installed_plugins.json
- *
- * Supports three formats:
- * - v1: { version: 1, plugins: Record<string, PluginInstallation> }
- * - v2: { version: 2, plugins: Record<string, PluginInstallation[]> }
- * - v3: InstalledPluginEntryV3[] (flat array, current Claude Code format)
- */
-export type InstalledPluginsDatabase =
-  | InstalledPluginsDatabaseV1
-  | InstalledPluginsDatabaseV2
-  | InstalledPluginEntryV3[]
-
-/**
- * Plugin author information
- */
-export interface PluginAuthor {
-  name?: string
-  email?: string
-  url?: string
-}
-
-/**
- * Plugin manifest (plugin.json)
- * Located at <plugin_root>/.claude-plugin/plugin.json
- */
-export interface PluginManifest {
-  name: string
-  version?: string
-  description?: string
-  author?: PluginAuthor
-  homepage?: string
-  repository?: string
-  license?: string
-  keywords?: string[]
-  
-  // Component paths (can be string or array)
-  commands?: string | string[]
-  agents?: string | string[]
-  skills?: string | string[]
-  hooks?: string | HooksConfig
-  mcpServers?: string | McpServersConfig
-  lspServers?: string | LspServersConfig
-  outputStyles?: string | string[]
-}
-
-/**
- * Hooks configuration
- */
-export type HookEntry =
-  | { type: "command"; command?: string }
-  | { type: "prompt"; prompt?: string }
-  | { type: "agent"; agent?: string }
-  | { type: "http"; url: string; headers?: Record<string, string>; allowedEnvVars?: string[]; timeout?: number }
-
-export interface HookMatcher {
-  matcher?: string
-  hooks: HookEntry[]
-}
-
-export interface HooksConfig {
-  hooks?: {
-    PreToolUse?: HookMatcher[]
-    PostToolUse?: HookMatcher[]
-    PostToolUseFailure?: HookMatcher[]
-    PermissionRequest?: HookMatcher[]
-    UserPromptSubmit?: HookMatcher[]
-    Notification?: HookMatcher[]
-    Stop?: HookMatcher[]
-    SubagentStart?: HookMatcher[]
-    SubagentStop?: HookMatcher[]
-    SessionStart?: HookMatcher[]
-    SessionEnd?: HookMatcher[]
-    PreCompact?: HookMatcher[]
-  }
-}
-
-/**
- * MCP servers configuration in plugin
- */
-export interface PluginMcpServer {
-  command?: string
-  args?: string[]
-  env?: Record<string, string>
-  cwd?: string
-  url?: string
-  type?: "stdio" | "http" | "sse"
-  disabled?: boolean
-}
-
-export interface McpServersConfig {
-  mcpServers?: Record<string, PluginMcpServer>
-}
-
-/**
- * LSP server configuration
- */
-export interface LspServerConfig {
-  command: string
-  args?: string[]
-  extensionToLanguage: Record<string, string>
-  transport?: "stdio" | "socket"
-  env?: Record<string, string>
-  initializationOptions?: Record<string, unknown>
-  settings?: Record<string, unknown>
-  workspaceFolder?: string
-  startupTimeout?: number
-  shutdownTimeout?: number
-  restartOnCrash?: boolean
-  maxRestarts?: number
-  loggingConfig?: {
-    args?: string[]
-    env?: Record<string, string>
-  }
-}
-
-export interface LspServersConfig {
-  [language: string]: LspServerConfig
-}
-
-/**
- * Loaded plugin with all resolved components
- */
-export interface LoadedPlugin {
-  name: string
-  version: string
-  scope: PluginScope
-  installPath: string
-  manifest?: PluginManifest
-  pluginKey: string
-  
-  // Resolved paths for components
-  commandsDir?: string
-  agentsDir?: string
-  skillsDir?: string
-  hooksPath?: string
-  mcpPath?: string
-  lspPath?: string
-}
-
-/**
- * Plugin load result with all components
- */
-export interface PluginLoadResult {
-  plugins: LoadedPlugin[]
-  errors: PluginLoadError[]
-}
-
-export interface PluginLoadError {
-  pluginKey: string
-  installPath: string
-  error: string
-}
-
-/**
- * Claude settings from ~/.claude/settings.json
- */
-export interface ClaudeSettings {
-  enabledPlugins?: Record<string, boolean>
-  // Other settings we don't use
-  [key: string]: unknown
-}
-
-/**
- * Plugin loader options
- */
-export interface PluginLoaderOptions {
-  /**
-   * Override the plugins home directory for testing.
-   * If not provided, uses CLAUDE_PLUGINS_HOME env var or ~/.claude/plugins
-   */
-  pluginsHomeOverride?: string
-
-  /**
-   * Override plugin manifest loading for testing.
-   * Return null to force plugin name derivation from the plugin key.
-   */
-  loadPluginManifestOverride?: (installPath: string) => PluginManifest | null
-
-  /**
-   * Override enabled plugins from hiai-opencode config.
-   * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
-   * Value: true = enabled, false = disabled
-   * 
-   * This takes precedence over ~/.claude/settings.json enabledPlugins
-   */
-  enabledPluginsOverride?: Record<string, boolean>
-}

package/src/features/claude-code-session-state/index.ts

@@ -1 +0,0 @@
-export * from "./state"

package/src/features/claude-code-session-state/state.ts

@@ -1,154 +0,0 @@
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-
-export const subagentSessions = new Set<string>()
-export const syncSubagentSessions = new Set<string>()
-
-let _mainSessionID: string | undefined
-
-export function setMainSession(id: string | undefined) {
-  _mainSessionID = id
-}
-
-export function getMainSessionID(): string | undefined {
-  return _mainSessionID
-}
-
-const registeredAgentNames = new Set<string>()
-const registeredAgentAliases = new Map<string, string>()
-
-const ZERO_WIDTH_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g
-const LEGACY_AGENT_KEY_TO_CANONICAL: Record<string, string> = {
-  general: "bob",
-  build: "bob",
-  zoe: "bob",
-  "pre-plan": "strategist",
-  "plan-consultant": "strategist",
-  explore: "researcher",
-  librarian: "researcher",
-  logician: "strategist",
-  "code-reviewer": "critic",
-  "systematic-debugger": "critic",
-  "ledger-creator": "platform-manager",
-  bootstrapper: "platform-manager",
-  "project-initializer": "platform-manager",
-  mindmodel: "platform-manager",
-  subagent: "coder",
-  ui: "multimodal",
-}
-const CANONICAL_AGENT_COMPATIBILITY_KEYS: Record<string, string[]> = {
-  multimodal: ["ui"],
-}
-
-function normalizeRegisteredAgentName(name: string): string {
-  return name.replace(ZERO_WIDTH_CHARACTERS_REGEX, "").toLowerCase()
-}
-
-function normalizeStoredAgentName(name: string): string {
-  return name.replace(ZERO_WIDTH_CHARACTERS_REGEX, "")
-}
-
-function addRegisteredAlias(key: string, alias: string, force = false): void {
-  if (!key) {
-    return
-  }
-  registeredAgentNames.add(key)
-  if (force || !registeredAgentAliases.has(key)) {
-    registeredAgentAliases.set(key, alias)
-  }
-}
-
-function canonicalizeAgentKey(agentKey: string): string {
-  return LEGACY_AGENT_KEY_TO_CANONICAL[agentKey] ?? agentKey
-}
-
-function appendLookupKey(keys: string[], value: string): void {
-  if (!value || keys.includes(value)) {
-    return
-  }
-  keys.push(value)
-}
-
-function getAgentLookupKeys(name: string): string[] {
-  const keys: string[] = []
-  const normalizedName = normalizeRegisteredAgentName(name)
-  const configKey = normalizeRegisteredAgentName(getAgentConfigKey(name))
-
-  appendLookupKey(keys, normalizedName)
-  appendLookupKey(keys, configKey)
-
-  const canonicalFromName = canonicalizeAgentKey(normalizedName)
-  const canonicalFromConfig = canonicalizeAgentKey(configKey)
-  appendLookupKey(keys, canonicalFromName)
-  appendLookupKey(keys, canonicalFromConfig)
-
-  for (const key of [...keys]) {
-    for (const compatibilityKey of CANONICAL_AGENT_COMPATIBILITY_KEYS[key] ?? []) {
-      appendLookupKey(keys, compatibilityKey)
-    }
-  }
-
-  return keys
-}
-
-export function registerAgentName(name: string): void {
-  const normalizedName = normalizeRegisteredAgentName(name)
-  const configKey = normalizeRegisteredAgentName(getAgentConfigKey(name))
-  const canonicalConfigKey = canonicalizeAgentKey(configKey)
-  const forceCanonicalAlias = canonicalConfigKey === configKey
-
-  addRegisteredAlias(normalizedName, name)
-  addRegisteredAlias(configKey, name)
-  addRegisteredAlias(canonicalConfigKey, name, forceCanonicalAlias)
-  for (const compatibilityKey of CANONICAL_AGENT_COMPATIBILITY_KEYS[canonicalConfigKey] ?? []) {
-    addRegisteredAlias(compatibilityKey, name, forceCanonicalAlias)
-  }
-}
-
-export function isAgentRegistered(name: string): boolean {
-  return registeredAgentNames.has(normalizeRegisteredAgentName(name))
-}
-
-export function resolveRegisteredAgentName(name: string | undefined): string | undefined {
-  if (typeof name !== "string") {
-    return undefined
-  }
-
-  for (const lookupKey of getAgentLookupKeys(name)) {
-    const aliasMatch = registeredAgentAliases.get(lookupKey)
-    if (aliasMatch !== undefined) {
-      return aliasMatch
-    }
-  }
-
-  return normalizeStoredAgentName(name)
-}
-
-/** @internal For testing only */
-export function _resetForTesting(): void {
-  _mainSessionID = undefined
-  subagentSessions.clear()
-  syncSubagentSessions.clear()
-  sessionAgentMap.clear()
-  registeredAgentNames.clear()
-  registeredAgentAliases.clear()
-}
-
-const sessionAgentMap = new Map<string, string>()
-
-export function setSessionAgent(sessionID: string, agent: string): void {
-  if (!sessionAgentMap.has(sessionID)) {
-    sessionAgentMap.set(sessionID, normalizeStoredAgentName(agent))
-  }
-}
-
-export function updateSessionAgent(sessionID: string, agent: string): void {
-  sessionAgentMap.set(sessionID, normalizeStoredAgentName(agent))
-}
-
-export function getSessionAgent(sessionID: string): string | undefined {
-  return sessionAgentMap.get(sessionID)
-}
-
-export function clearSessionAgent(sessionID: string): void {
-  sessionAgentMap.delete(sessionID)
-}

package/src/features/claude-tasks/session-storage.ts

@@ -1,52 +0,0 @@
-import { join } from "path"
-import { existsSync, readdirSync, statSync } from "fs"
-import { getTaskDir } from "./storage"
-import type { HiaiOpenCodeConfig } from "../../config/schema"
-
-export function getSessionTaskDir(
-  config: Partial<HiaiOpenCodeConfig>,
-  sessionID: string,
-): string {
-  return join(getTaskDir(config), sessionID)
-}
-
-export function listSessionTaskFiles(
-  config: Partial<HiaiOpenCodeConfig>,
-  sessionID: string,
-): string[] {
-  const dir = getSessionTaskDir(config, sessionID)
-  if (!existsSync(dir)) return []
-  return readdirSync(dir)
-    .filter((f) => f.endsWith(".json") && f.startsWith("T-"))
-    .map((f) => f.replace(".json", ""))
-}
-
-export function listAllSessionDirs(
-  config: Partial<HiaiOpenCodeConfig>,
-): string[] {
-  const baseDir = getTaskDir(config)
-  if (!existsSync(baseDir)) return []
-  return readdirSync(baseDir).filter((entry) => {
-    const fullPath = join(baseDir, entry)
-    return statSync(fullPath).isDirectory()
-  })
-}
-
-export interface TaskLocation {
-  path: string
-  sessionID: string
-}
-
-export function findTaskAcrossSessions(
-  config: Partial<HiaiOpenCodeConfig>,
-  taskId: string,
-): TaskLocation | null {
-  const sessionDirs = listAllSessionDirs(config)
-  for (const sessionID of sessionDirs) {
-    const taskPath = join(getSessionTaskDir(config, sessionID), `${taskId}.json`)
-    if (existsSync(taskPath)) {
-      return { path: taskPath, sessionID }
-    }
-  }
-  return null
-}

package/src/features/claude-tasks/storage.ts

@@ -1,169 +0,0 @@
-import { join, dirname, basename, isAbsolute } from "path"
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, readdirSync } from "fs"
-import { randomUUID } from "crypto"
-import { getOpenCodeConfigDir } from "../../shared/opencode-config-dir"
-import type { z } from "zod"
-import type { HiaiOpenCodeConfig } from "../../config/schema"
-
-export function getTaskDir(config: Partial<HiaiOpenCodeConfig> = {}): string {
-  const tasksConfig = config.bob?.tasks
-  const storagePath = tasksConfig?.storage_path
-
-  if (storagePath) {
-    return isAbsolute(storagePath) ? storagePath : join(process.cwd(), storagePath)
-  }
-
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" })
-  const listId = resolveTaskListId(config)
-  return join(configDir, "tasks", listId)
-}
-
-export function sanitizePathSegment(value: string): string {
-  return value.replace(/[^a-zA-Z0-9_-]/g, "-") || "default"
-}
-
-export function resolveTaskListId(config: Partial<HiaiOpenCodeConfig> = {}): string {
-  const envId = process.env.ULTRAWORK_TASK_LIST_ID?.trim()
-  if (envId) return sanitizePathSegment(envId)
-
-  const claudeEnvId = process.env.CLAUDE_CODE_TASK_LIST_ID?.trim()
-  if (claudeEnvId) return sanitizePathSegment(claudeEnvId)
-
-  const configId = config.bob?.tasks?.task_list_id?.trim()
-  if (configId) return sanitizePathSegment(configId)
-
-  return sanitizePathSegment(basename(process.cwd()))
-}
-
-export function ensureDir(dirPath: string): void {
-  if (!existsSync(dirPath)) {
-    mkdirSync(dirPath, { recursive: true })
-  }
-}
-
-export function readJsonSafe<T>(filePath: string, schema: z.ZodType<T>): T | null {
-  try {
-    if (!existsSync(filePath)) {
-      return null
-    }
-
-    const content = readFileSync(filePath, "utf-8")
-    const parsed = JSON.parse(content)
-    const result = schema.safeParse(parsed)
-
-    if (!result.success) {
-      return null
-    }
-
-    return result.data
-  } catch {
-    return null
-  }
-}
-
-export function writeJsonAtomic(filePath: string, data: unknown): void {
-  const dir = dirname(filePath)
-  ensureDir(dir)
-
-  const tempPath = `${filePath}.tmp.${Date.now()}`
-
-  try {
-    writeFileSync(tempPath, JSON.stringify(data, null, 2), "utf-8")
-    renameSync(tempPath, filePath)
-  } catch (error) {
-    try {
-      if (existsSync(tempPath)) {
-        unlinkSync(tempPath)
-      }
-    } catch {
-      // Ignore cleanup errors
-    }
-    throw error
-  }
-}
-
-const STALE_LOCK_THRESHOLD_MS = 30000
-
-export function generateTaskId(): string {
-  return `T-${randomUUID()}`
-}
-
-export function listTaskFiles(config: Partial<HiaiOpenCodeConfig> = {}): string[] {
-  const dir = getTaskDir(config)
-  if (!existsSync(dir)) return []
-  return readdirSync(dir)
-    .filter((f) => f.endsWith('.json') && f.startsWith('T-'))
-    .map((f) => f.replace('.json', ''))
-}
-
-export function acquireLock(dirPath: string): { acquired: boolean; release: () => void } {
-  const lockPath = join(dirPath, ".lock")
-  const lockId = randomUUID()
-
-  const createLock = (timestamp: number) => {
-    writeFileSync(lockPath, JSON.stringify({ id: lockId, timestamp }), {
-      encoding: "utf-8",
-      flag: "wx",
-    })
-  }
-
-  const isStale = () => {
-    try {
-      const lockContent = readFileSync(lockPath, "utf-8")
-      const lockData = JSON.parse(lockContent)
-      const lockAge = Date.now() - lockData.timestamp
-      return lockAge > STALE_LOCK_THRESHOLD_MS
-    } catch {
-      return true
-    }
-  }
-
-  const tryAcquire = () => {
-    const now = Date.now()
-    try {
-      createLock(now)
-      return true
-    } catch (error) {
-      if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
-        return false
-      }
-      throw error
-    }
-  }
-
-  ensureDir(dirPath)
-
-  let acquired = tryAcquire()
-  if (!acquired && isStale()) {
-    try {
-      unlinkSync(lockPath)
-    } catch {
-      // Ignore cleanup errors
-    }
-    acquired = tryAcquire()
-  }
-
-  if (!acquired) {
-    return {
-      acquired: false,
-      release: () => {
-        // No-op release for failed acquisition
-      },
-    }
-  }
-
-  return {
-    acquired: true,
-    release: () => {
-      try {
-        if (!existsSync(lockPath)) return
-        const lockContent = readFileSync(lockPath, "utf-8")
-        const lockData = JSON.parse(lockContent)
-        if (lockData.id !== lockId) return
-        unlinkSync(lockPath)
-      } catch {
-        // Ignore cleanup errors
-      }
-    },
-  }
-}

package/src/features/claude-tasks/types.ts

@@ -1,20 +0,0 @@
-import { z } from "zod"
-
-export const TaskStatusSchema = z.enum(["pending", "in_progress", "completed", "deleted"])
-export type TaskStatus = z.infer<typeof TaskStatusSchema>
-
-export const TaskSchema = z
-  .object({
-    id: z.string(),
-    subject: z.string(),
-    description: z.string(),
-    status: TaskStatusSchema,
-    activeForm: z.string().optional(),
-    blocks: z.array(z.string()),
-    blockedBy: z.array(z.string()),
-    owner: z.string().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-  })
-  .strict()
-
-export type Task = z.infer<typeof TaskSchema>