@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/tools/session-manager/tools.ts

@@ -1,197 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import {
-  SESSION_LIST_DESCRIPTION,
-  SESSION_READ_DESCRIPTION,
-  SESSION_SEARCH_DESCRIPTION,
-  SESSION_INFO_DESCRIPTION,
-} from "./constants"
-import { getAllSessions, getMainSessions, getSessionInfo, readSessionMessages, readSessionTodos, sessionExists, setStorageClient } from "./storage"
-import {
-  filterSessionsByDate,
-  formatSessionInfo,
-  formatSessionList,
-  formatSessionMessages,
-  formatSearchResults,
-  searchInSession,
-} from "./session-formatter"
-import type { SessionListArgs, SessionReadArgs, SessionSearchArgs, SessionInfoArgs, SearchResult } from "./types"
-
-const SEARCH_TIMEOUT_MS = 60_000
-const MAX_SESSIONS_TO_SCAN = 50
-
-function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
-  return Promise.race([
-    promise,
-    new Promise<T>((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms)),
-  ])
-}
-
-type SessionManagerToolDeps = {
-  getAllSessions: typeof getAllSessions
-  getMainSessions: typeof getMainSessions
-  getSessionInfo: typeof getSessionInfo
-  readSessionMessages: typeof readSessionMessages
-  readSessionTodos: typeof readSessionTodos
-  sessionExists: typeof sessionExists
-  setStorageClient: typeof setStorageClient
-  filterSessionsByDate: typeof filterSessionsByDate
-  formatSessionInfo: typeof formatSessionInfo
-  formatSessionList: typeof formatSessionList
-  formatSessionMessages: typeof formatSessionMessages
-  formatSearchResults: typeof formatSearchResults
-  searchInSession: typeof searchInSession
-}
-
-const defaultSessionManagerToolDeps: SessionManagerToolDeps = {
-  getAllSessions,
-  getMainSessions,
-  getSessionInfo,
-  readSessionMessages,
-  readSessionTodos,
-  sessionExists,
-  setStorageClient,
-  filterSessionsByDate,
-  formatSessionInfo,
-  formatSessionList,
-  formatSessionMessages,
-  formatSearchResults,
-  searchInSession,
-}
-
-export function createSessionManagerTools(
-  ctx: PluginInput,
-  deps: Partial<SessionManagerToolDeps> = {},
-): Record<string, ToolDefinition> {
-  const resolvedDeps: SessionManagerToolDeps = {
-    ...defaultSessionManagerToolDeps,
-    ...deps,
-  }
-  // Initialize storage client for SDK-based operations (beta mode)
-  resolvedDeps.setStorageClient(ctx.client)
-
-  const session_list: ToolDefinition = tool({
-    description: SESSION_LIST_DESCRIPTION,
-    args: {
-      limit: tool.schema.number().optional().describe("Maximum number of sessions to return"),
-      from_date: tool.schema.string().optional().describe("Filter sessions from this date (ISO 8601 format)"),
-      to_date: tool.schema.string().optional().describe("Filter sessions until this date (ISO 8601 format)"),
-      project_path: tool.schema.string().optional().describe("Filter sessions by project path (default: current working directory)"),
-    },
-    execute: async (args: SessionListArgs, _context) => {
-      try {
-        const directory = args.project_path ?? ctx.directory
-        let sessions = await resolvedDeps.getMainSessions({ directory })
-        let sessionIDs = sessions.map((s) => s.id)
-
-        if (args.from_date || args.to_date) {
-          sessionIDs = await resolvedDeps.filterSessionsByDate(sessionIDs, args.from_date, args.to_date)
-        }
-
-        if (args.limit && args.limit > 0) {
-          sessionIDs = sessionIDs.slice(0, args.limit)
-        }
-
-        return await resolvedDeps.formatSessionList(sessionIDs)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  const session_read: ToolDefinition = tool({
-    description: SESSION_READ_DESCRIPTION,
-    args: {
-      session_id: tool.schema.string().describe("Session ID to read"),
-      include_todos: tool.schema.boolean().optional().describe("Include todo list if available (default: false)"),
-      include_transcript: tool.schema.boolean().optional().describe("Include transcript log if available (default: false)"),
-      limit: tool.schema.number().optional().describe("Maximum number of messages to return (default: all)"),
-    },
-    execute: async (args: SessionReadArgs, _context) => {
-      try {
-        if (!(await resolvedDeps.sessionExists(args.session_id))) {
-          return `Session not found: ${args.session_id}`
-        }
-
-        let messages = await resolvedDeps.readSessionMessages(args.session_id)
-
-        if (messages.length === 0) {
-          return `Session not found: ${args.session_id}`
-        }
-
-        if (args.limit && args.limit > 0) {
-          messages = messages.slice(0, args.limit)
-        }
-
-        const todos = args.include_todos ? await resolvedDeps.readSessionTodos(args.session_id) : undefined
-
-        return resolvedDeps.formatSessionMessages(messages, args.include_todos, todos)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  const session_search: ToolDefinition = tool({
-    description: SESSION_SEARCH_DESCRIPTION,
-    args: {
-      query: tool.schema.string().describe("Search query string"),
-      session_id: tool.schema.string().optional().describe("Search within specific session only (default: all sessions)"),
-      case_sensitive: tool.schema.boolean().optional().describe("Case-sensitive search (default: false)"),
-      limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 20)"),
-    },
-    execute: async (args: SessionSearchArgs, _context) => {
-      try {
-        const resultLimit = args.limit && args.limit > 0 ? args.limit : 20
-
-        const searchOperation = async (): Promise<SearchResult[]> => {
-          if (args.session_id) {
-            return resolvedDeps.searchInSession(args.session_id, args.query, args.case_sensitive, resultLimit)
-          }
-
-          const allSessions = await resolvedDeps.getAllSessions()
-          const sessionsToScan = allSessions.slice(0, MAX_SESSIONS_TO_SCAN)
-
-          const allResults: SearchResult[] = []
-          for (const sid of sessionsToScan) {
-            if (allResults.length >= resultLimit) break
-
-            const remaining = resultLimit - allResults.length
-            const sessionResults = await resolvedDeps.searchInSession(sid, args.query, args.case_sensitive, remaining)
-            allResults.push(...sessionResults)
-          }
-
-          return allResults.slice(0, resultLimit)
-        }
-
-        const results = await withTimeout(searchOperation(), SEARCH_TIMEOUT_MS, "Search")
-
-        return resolvedDeps.formatSearchResults(results)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  const session_info: ToolDefinition = tool({
-    description: SESSION_INFO_DESCRIPTION,
-    args: {
-      session_id: tool.schema.string().describe("Session ID to inspect"),
-    },
-    execute: async (args: SessionInfoArgs, _context) => {
-      try {
-        const info = await resolvedDeps.getSessionInfo(args.session_id)
-
-        if (!info) {
-          return `Session not found: ${args.session_id}`
-        }
-
-        return resolvedDeps.formatSessionInfo(info)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  return { session_list, session_read, session_search, session_info }
-}

package/src/tools/session-manager/types.ts

@@ -1,99 +0,0 @@
-export interface SessionMessage {
-  id: string
-  role: "user" | "assistant"
-  agent?: string
-  time?: {
-    created: number
-    updated?: number
-  }
-  parts: MessagePart[]
-}
-
-export interface MessagePart {
-  id: string
-  type: string
-  text?: string
-  thinking?: string
-  tool?: string
-  callID?: string
-  input?: Record<string, unknown>
-  output?: string
-  error?: string
-}
-
-export interface SessionInfo {
-  id: string
-  message_count: number
-  first_message?: Date
-  last_message?: Date
-  agents_used: string[]
-  has_todos: boolean
-  has_transcript: boolean
-  todos?: TodoItem[]
-  transcript_entries?: number
-}
-
-export interface TodoItem {
-  id?: string;
-  content: string;
-  status: "pending" | "in_progress" | "completed" | "cancelled";
-  priority?: string;
-}
-
-export interface SearchResult {
-  session_id: string
-  message_id: string
-  role: string
-  excerpt: string
-  match_count: number
-  timestamp?: number
-}
-
-export interface SessionMetadata {
-  id: string
-  version?: string
-  projectID: string
-  directory: string
-  title?: string
-  parentID?: string
-  time: {
-    created: number
-    updated: number
-  }
-  summary?: {
-    additions: number
-    deletions: number
-    files: number
-  }
-}
-
-export interface SessionListArgs {
-  limit?: number
-  offset?: number
-  from_date?: string
-  to_date?: string
-  project_path?: string
-}
-
-export interface SessionReadArgs {
-  session_id: string
-  include_todos?: boolean
-  include_transcript?: boolean
-  limit?: number
-}
-
-export interface SessionSearchArgs {
-  query: string
-  session_id?: string
-  case_sensitive?: boolean
-  limit?: number
-}
-
-export interface SessionInfoArgs {
-  session_id: string
-}
-
-export interface SessionDeleteArgs {
-  session_id: string
-  confirm: boolean
-}

package/src/tools/shared/semaphore.ts

@@ -1,32 +0,0 @@
-/**
- * Simple counting semaphore to limit concurrent process execution.
- * Used to prevent multiple ripgrep processes from saturating CPU.
- */
-export class Semaphore {
-  private queue: (() => void)[] = []
-  private running = 0
-
-  constructor(private readonly max: number) {}
-
-  async acquire(): Promise<void> {
-    if (this.running < this.max) {
-      this.running++
-      return
-    }
-    return new Promise<void>((resolve) => {
-      this.queue.push(() => {
-        this.running++
-        resolve()
-      })
-    })
-  }
-
-  release(): void {
-    this.running--
-    const next = this.queue.shift()
-    if (next) next()
-  }
-}
-
-/** Global semaphore limiting concurrent ripgrep processes to 2 */
-export const rgSemaphore = new Semaphore(2)

package/src/tools/skill/constants.ts

@@ -1,14 +0,0 @@
-export const TOOL_NAME = "skill" as const
-
-export const TOOL_DESCRIPTION_NO_SKILLS = "Load a skill or execute a slash command to get detailed instructions for a specific task. No skills are currently available."
-
-export const TOOL_DESCRIPTION_PREFIX = `Load a skill or execute a slash command to get detailed instructions for a specific task.
-
-Skills and commands provide specialized knowledge and step-by-step guidance.
-Use this when a task matches an available skill's or command's description.
-
-**How to use:**
-- Call with a skill name: name='review-work'
-- Call with a command name (without leading slash): name='publish'
-- The tool will return detailed instructions with your context applied.
-`

package/src/tools/skill/description-formatter.ts

@@ -1,61 +0,0 @@
-import { TOOL_DESCRIPTION_NO_SKILLS, TOOL_DESCRIPTION_PREFIX } from "./constants"
-import { sortByScopePriority } from "./scope-priority"
-import type { SkillInfo } from "./types"
-import type { CommandInfo } from "../slashcommand/types"
-
-function formatSkillCommand(skill: SkillInfo): string {
-  const lines = [
-    "  <command>",
-    `    <name>/${skill.name}</name>`,
-    `    <description>${skill.description}</description>`,
-    `    <scope>${skill.scope}</scope>`,
-  ]
-
-  if (skill.compatibility) {
-    lines.push(`    <compatibility>${skill.compatibility}</compatibility>`)
-  }
-
-  lines.push("  </command>")
-  return lines.join("\n")
-}
-
-function formatSlashCommand(command: CommandInfo): string {
-  const argumentHint = typeof command.metadata.argumentHint === "string"
-    ? command.metadata.argumentHint.trim()
-    : undefined
-  const lines = [
-    "  <command>",
-    `    <name>/${command.name}</name>`,
-    `    <description>${command.metadata.description || "(no description)"}</description>`,
-    `    <scope>${command.scope}</scope>`,
-  ]
-
-  if (argumentHint) {
-    lines.push(`    <argument>${argumentHint}</argument>`)
-  }
-
-  lines.push("  </command>")
-  return lines.join("\n")
-}
-
-export function formatCombinedDescription(skills: SkillInfo[], commands: CommandInfo[]): string {
-  if (skills.length === 0 && commands.length === 0) {
-    return TOOL_DESCRIPTION_NO_SKILLS
-  }
-
-  const availableItems = [
-    ...sortByScopePriority(skills).map(formatSkillCommand),
-    ...sortByScopePriority(commands).map(formatSlashCommand),
-  ]
-
-  if (availableItems.length === 0) {
-    return TOOL_DESCRIPTION_PREFIX
-  }
-
-  return `${TOOL_DESCRIPTION_PREFIX}
-<available_items>
-Priority: project > user > opencode > builtin/plugin | Skills listed before commands
-Invoke via: skill(name="item-name") - omit leading slash for commands.
-${availableItems.join("\n")}
-</available_items>`
-}

package/src/tools/skill/index.ts

@@ -1,3 +0,0 @@
-export * from "./constants"
-export * from "./types"
-export { skill, createSkillTool } from "./tools"

package/src/tools/skill/mcp-capability-formatter.ts

@@ -1,97 +0,0 @@
-import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js"
-import { sanitizeJsonSchema } from "../../plugin/normalize-tool-arg-schemas"
-import type {
-  SkillMcpClientInfo,
-  SkillMcpManager,
-  SkillMcpServerContext,
-} from "../../features/skill-mcp-manager"
-import type { LoadedSkill } from "../../features/opencode-skill-loader"
-
-export async function formatMcpCapabilities(
-  skill: LoadedSkill,
-  manager: SkillMcpManager,
-  sessionID: string
-): Promise<string | null> {
-  if (!skill.mcpConfig || Object.keys(skill.mcpConfig).length === 0) {
-    return null
-  }
-
-  const sections: string[] = ["", "## Available MCP Servers", ""]
-
-  for (const [serverName, config] of Object.entries(skill.mcpConfig)) {
-    const info: SkillMcpClientInfo = {
-      serverName,
-      skillName: skill.name,
-      sessionID,
-      scope: skill.scope,
-    }
-    const context: SkillMcpServerContext = {
-      config,
-      skillName: skill.name,
-    }
-
-    sections.push(`### ${serverName}`, "")
-
-    try {
-      const [tools, resources, prompts] = await Promise.all([
-        manager.listTools(info, context).catch(() => []),
-        manager.listResources(info, context).catch(() => []),
-        manager.listPrompts(info, context).catch(() => []),
-      ])
-
-      appendToolSections(sections, tools as Tool[])
-      appendResourceSection(sections, resources as Resource[])
-      appendPromptSection(sections, prompts as Prompt[])
-
-      if (tools.length === 0 && resources.length === 0 && prompts.length === 0) {
-        sections.push("*No capabilities discovered*")
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error)
-      sections.push(`*Failed to connect: ${errorMessage.split("\n")[0]}*`)
-    }
-
-    sections.push("", `Use \`skill_mcp\` tool with \`mcp_name=\"${serverName}\"\` to invoke.`, "")
-  }
-
-  return sections.join("\n")
-}
-
-function appendToolSections(sections: string[], tools: Tool[]): void {
-  if (tools.length === 0) {
-    return
-  }
-
-  sections.push("**Tools:**", "")
-
-  for (const toolDefinition of tools) {
-    sections.push(`#### \`${toolDefinition.name}\``)
-    if (toolDefinition.description) {
-      sections.push(toolDefinition.description)
-    }
-    sections.push(
-      "",
-      "**inputSchema:**",
-      "```json",
-      JSON.stringify(sanitizeJsonSchema(toolDefinition.inputSchema), null, 2),
-      "```",
-      ""
-    )
-  }
-}
-
-function appendResourceSection(sections: string[], resources: Resource[]): void {
-  if (resources.length === 0) {
-    return
-  }
-
-  sections.push(`**Resources**: ${resources.map((resource) => resource.uri).join(", ")}`)
-}
-
-function appendPromptSection(sections: string[], prompts: Prompt[]): void {
-  if (prompts.length === 0) {
-    return
-  }
-
-  sections.push(`**Prompts**: ${prompts.map((prompt) => prompt.name).join(", ")}`)
-}

package/src/tools/skill/native-skills.ts

@@ -1,62 +0,0 @@
-import type { SkillInfo } from "./types"
-import type { LoadedSkill } from "../../features/opencode-skill-loader"
-
-export type NativeSkillEntry = {
-  name: string
-  description: string
-  location: string
-  content: string
-}
-
-export function loadedSkillToInfo(skill: LoadedSkill): SkillInfo {
-  return {
-    name: skill.name,
-    description: skill.definition.description || "",
-    location: skill.path,
-    scope: skill.scope,
-    license: skill.license,
-    compatibility: skill.compatibility,
-    metadata: skill.metadata,
-    allowedTools: skill.allowedTools,
-  }
-}
-
-function nativeSkillToLoadedSkill(native: NativeSkillEntry): LoadedSkill {
-  return {
-    name: native.name,
-    path: native.location,
-    definition: {
-      name: native.name,
-      description: native.description,
-      template: native.content,
-    },
-    scope: "config",
-  }
-}
-
-export function mergeNativeSkills(skills: LoadedSkill[], nativeSkills: NativeSkillEntry[]): void {
-  const knownNames = new Set(skills.map((skill) => skill.name))
-  for (const native of nativeSkills) {
-    if (knownNames.has(native.name)) continue
-    skills.push(nativeSkillToLoadedSkill(native))
-    knownNames.add(native.name)
-  }
-}
-
-export function mergeNativeSkillInfos(skillInfos: SkillInfo[], nativeSkills: NativeSkillEntry[]): void {
-  const knownNames = new Set(skillInfos.map((skill) => skill.name))
-  for (const native of nativeSkills) {
-    if (knownNames.has(native.name)) continue
-    skillInfos.push({
-      name: native.name,
-      description: native.description,
-      location: native.location,
-      scope: "config",
-    })
-    knownNames.add(native.name)
-  }
-}
-
-export function isPromiseLike<TValue>(value: TValue | Promise<TValue>): value is Promise<TValue> {
-  return typeof value === "object" && value !== null && "then" in value
-}

package/src/tools/skill/scope-priority.ts

@@ -1,17 +0,0 @@
-export const SCOPE_PRIORITY: Record<string, number> = {
-  project: 4,
-  user: 3,
-  opencode: 2,
-  "opencode-project": 2,
-  plugin: 1,
-  config: 1,
-  builtin: 1,
-}
-
-export function sortByScopePriority<TItem extends { scope: string }>(items: TItem[]): TItem[] {
-  return [...items].sort((left, right) => {
-    const leftPriority = SCOPE_PRIORITY[left.scope] || 0
-    const rightPriority = SCOPE_PRIORITY[right.scope] || 0
-    return rightPriority - leftPriority
-  })
-}

package/src/tools/skill/skill-body.ts

@@ -1,26 +0,0 @@
-import type { LoadedSkill } from "../../features/opencode-skill-loader"
-import { extractSkillTemplate } from "../../features/opencode-skill-loader/skill-content"
-
-const SKILL_INSTRUCTION_PATTERN = /<skill-instruction>([\s\S]*?)<\/skill-instruction>/
-
-function trimSkillInstruction(template: string): string {
-  const templateMatch = template.match(SKILL_INSTRUCTION_PATTERN)
-  return templateMatch ? templateMatch[1].trim() : template
-}
-
-export async function extractSkillBody(skill: LoadedSkill): Promise<string> {
-  if (skill.lazyContent) {
-    const fullTemplate = await skill.lazyContent.load()
-    return trimSkillInstruction(fullTemplate)
-  }
-
-  if (skill.scope === "config" && skill.definition.template) {
-    return trimSkillInstruction(skill.definition.template)
-  }
-
-  if (skill.path) {
-    return extractSkillTemplate(skill)
-  }
-
-  return trimSkillInstruction(skill.definition.template || "")
-}

package/src/tools/skill/skill-matcher.ts

@@ -1,40 +0,0 @@
-import { sortByScopePriority } from "./scope-priority"
-import type { CommandInfo } from "../slashcommand/types"
-import type { LoadedSkill } from "../../features/opencode-skill-loader"
-
-export function matchSkillByName(skills: LoadedSkill[], requestedName: string): LoadedSkill | undefined {
-  const normalizedName = requestedName.toLowerCase()
-  const exactMatch = skills.find((skill) => skill.name.toLowerCase() === normalizedName)
-  if (exactMatch) {
-    return exactMatch
-  }
-
-  const shortNameMatches = skills.filter((skill) => {
-    const parts = skill.name.split("/")
-    const shortName = parts[parts.length - 1]
-    return parts.length > 1 && shortName?.toLowerCase() === normalizedName
-  })
-
-  if (shortNameMatches.length === 1) {
-    return shortNameMatches[0]
-  }
-
-  return undefined
-}
-
-export function matchCommandByName(commands: CommandInfo[], requestedName: string): CommandInfo | undefined {
-  const normalizedName = requestedName.toLowerCase()
-  return sortByScopePriority(commands).find((command) => command.name.toLowerCase() === normalizedName)
-}
-
-export function findPartialMatches(
-  skills: LoadedSkill[],
-  commands: CommandInfo[],
-  requestedName: string
-): string[] {
-  const normalizedName = requestedName.toLowerCase()
-  return [
-    ...skills.map((skill) => skill.name),
-    ...commands.map((command) => `/${command.name}`),
-  ].filter((name) => name.toLowerCase().includes(normalizedName))
-}